← Back to branch summary

~ubuntu-branches/ubuntu/wily/bombono-dvd/wily

« back to all changes in this revision

Viewing changes to libs/boost-lib/boost/smart_ptr/detail/shared_ptr_nmt.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-11-04 11:46:25 UTC
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: james.westby@ubuntu.com-20101104114625-8xfdhvhpsm51i0nu
Tags: upstream-0.8.0
Import upstream version 0.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/boost-lib/boost/smart_ptr/detail/shared_ptr_nmt.hpp
 
1
#ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
 
2
#define BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED
 
3
 
 
4
//
 
5
//  detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates
 
6
//
 
7
//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
 
8
//  Copyright (c) 2001, 2002 Peter Dimov
 
9
//
 
10
//  Distributed under the Boost Software License, Version 1.0. (See
 
11
//  accompanying file LICENSE_1_0.txt or copy at
 
12
//  http://www.boost.org/LICENSE_1_0.txt)
 
13
//
 
14
//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
 
15
//
 
16
 
 
17
#include <boost/assert.hpp>
 
18
#include <boost/checked_delete.hpp>
 
19
#include <boost/throw_exception.hpp>
 
20
#include <boost/smart_ptr/detail/atomic_count.hpp>
 
21
 
 
22
#ifndef BOOST_NO_AUTO_PTR
 
23
# include <memory>          // for std::auto_ptr
 
24
#endif
 
25
 
 
26
#include <algorithm>        // for std::swap
 
27
#include <functional>       // for std::less
 
28
#include <new>              // for std::bad_alloc
 
29
 
 
30
namespace boost
 
31
{
 
32
 
 
33
template<class T> class shared_ptr
 
34
{
 
35
private:
 
36
 
 
37
    typedef detail::atomic_count count_type;
 
38
 
 
39
public:
 
40
 
 
41
    typedef T element_type;
 
42
    typedef T value_type;
 
43
 
 
44
    explicit shared_ptr(T * p = 0): px(p)
 
45
    {
 
46
#ifndef BOOST_NO_EXCEPTIONS
 
47
 
 
48
        try  // prevent leak if new throws
 
49
        {
 
50
            pn = new count_type(1);
 
51
        }
 
52
        catch(...)
 
53
        {
 
54
            boost::checked_delete(p);
 
55
            throw;
 
56
        }
 
57
 
 
58
#else
 
59
 
 
60
        pn = new count_type(1);
 
61
 
 
62
        if(pn == 0)
 
63
        {
 
64
            boost::checked_delete(p);
 
65
            boost::throw_exception(std::bad_alloc());
 
66
        }
 
67
 
 
68
#endif
 
69
    }
 
70
 
 
71
    ~shared_ptr()
 
72
    {
 
73
        if(--*pn == 0)
 
74
        {
 
75
            boost::checked_delete(px);
 
76
            delete pn;
 
77
        }
 
78
    }
 
79
 
 
80
    shared_ptr(shared_ptr const & r): px(r.px)  // never throws
 
81
    {
 
82
        pn = r.pn;
 
83
        ++*pn;
 
84
    }
 
85
 
 
86
    shared_ptr & operator=(shared_ptr const & r)
 
87
    {
 
88
        shared_ptr(r).swap(*this);
 
89
        return *this;
 
90
    }
 
91
 
 
92
#ifndef BOOST_NO_AUTO_PTR
 
93
 
 
94
    explicit shared_ptr(std::auto_ptr<T> & r)
 
95
    { 
 
96
        pn = new count_type(1); // may throw
 
97
        px = r.release(); // fix: moved here to stop leak if new throws
 
98
    } 
 
99
 
 
100
    shared_ptr & operator=(std::auto_ptr<T> & r)
 
101
    {
 
102
        shared_ptr(r).swap(*this);
 
103
        return *this;
 
104
    }
 
105
 
 
106
#endif
 
107
 
 
108
    void reset(T * p = 0)
 
109
    {
 
110
        BOOST_ASSERT(p == 0 || p != px);
 
111
        shared_ptr(p).swap(*this);
 
112
    }
 
113
 
 
114
    T & operator*() const  // never throws
 
115
    {
 
116
        BOOST_ASSERT(px != 0);
 
117
        return *px;
 
118
    }
 
119
 
 
120
    T * operator->() const  // never throws
 
121
    {
 
122
        BOOST_ASSERT(px != 0);
 
123
        return px;
 
124
    }
 
125
 
 
126
    T * get() const  // never throws
 
127
    {
 
128
        return px;
 
129
    }
 
130
 
 
131
    long use_count() const  // never throws
 
132
    {
 
133
        return *pn;
 
134
    }
 
135
 
 
136
    bool unique() const  // never throws
 
137
    {
 
138
        return *pn == 1;
 
139
    }
 
140
    
 
141
    void swap(shared_ptr<T> & other)  // never throws
 
142
    {
 
143
        std::swap(px, other.px);
 
144
        std::swap(pn, other.pn);
 
145
    }
 
146
 
 
147
private:
 
148
 
 
149
    T * px;            // contained pointer
 
150
    count_type * pn;   // ptr to reference counter
 
151
};
 
152
 
 
153
template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
 
154
{
 
155
    return a.get() == b.get();
 
156
}
 
157
 
 
158
template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
 
159
{
 
160
    return a.get() != b.get();
 
161
}
 
162
 
 
163
template<class T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
 
164
{
 
165
    return std::less<T*>()(a.get(), b.get());
 
166
}
 
167
 
 
168
template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b)
 
169
{
 
170
    a.swap(b);
 
171
}
 
172
 
 
173
// get_pointer() enables boost::mem_fn to recognize shared_ptr
 
174
 
 
175
template<class T> inline T * get_pointer(shared_ptr<T> const & p)
 
176
{
 
177
    return p.get();
 
178
}
 
179
 
 
180
} // namespace boost
 
181
 
 
182
#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED