1#ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED
2#define BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED
3
4//
5// intrusive_ptr.hpp
6//
7// Copyright (c) 2001, 2002 Peter Dimov
8//
9// Distributed under the Boost Software License, Version 1.0. (See
10// accompanying file LICENSE_1_0.txt or copy at
11// http://www.boost.org/LICENSE_1_0.txt)
12//
13// See http://www.boost.org/libs/smart_ptr/ for documentation.
14//
15
16#include <boost/config.hpp>
17
18#include <boost/assert.hpp>
19#include <boost/detail/workaround.hpp>
20#include <boost/smart_ptr/detail/sp_convertible.hpp>
21#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
22#include <boost/smart_ptr/detail/sp_noexcept.hpp>
23
24#include <boost/config/no_tr1/functional.hpp> // for std::less
25
26#if !defined(BOOST_NO_IOSTREAM)
27#if !defined(BOOST_NO_IOSFWD)
28#include <iosfwd> // for std::basic_ostream
29#else
30#include <ostream>
31#endif
32#endif
33
34
35namespace boost
36{
37
38//
39// intrusive_ptr
40//
41// A smart pointer that uses intrusive reference counting.
42//
43// Relies on unqualified calls to
44//
45// void intrusive_ptr_add_ref(T * p);
46// void intrusive_ptr_release(T * p);
47//
48// (p != 0)
49//
50// The object is responsible for destroying itself.
51//
52
53template<class T> class intrusive_ptr
54{
55private:
56
57 typedef intrusive_ptr this_type;
58
59public:
60
61 typedef T element_type;
62
63 BOOST_CONSTEXPR intrusive_ptr() BOOST_SP_NOEXCEPT : px( 0 )
64 {
65 }
66
67 intrusive_ptr( T * p, bool add_ref = true ): px( p )
68 {
69 if( px != 0 && add_ref ) intrusive_ptr_add_ref( px );
70 }
71
72#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
73
74 template<class U>
75#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
76
77 intrusive_ptr( intrusive_ptr<U> const & rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty() )
78
79#else
80
81 intrusive_ptr( intrusive_ptr<U> const & rhs )
82
83#endif
84 : px( rhs.get() )
85 {
86 if( px != 0 ) intrusive_ptr_add_ref( px );
87 }
88
89#endif
90
91 intrusive_ptr(intrusive_ptr const & rhs): px( rhs.px )
92 {
93 if( px != 0 ) intrusive_ptr_add_ref( px );
94 }
95
96 ~intrusive_ptr()
97 {
98 if( px != 0 ) intrusive_ptr_release( px );
99 }
100
101#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
102
103 template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
104 {
105 this_type(rhs).swap(*this);
106 return *this;
107 }
108
109#endif
110
111// Move support
112
113#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
114
115 intrusive_ptr(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT : px( rhs.px )
116 {
117 rhs.px = 0;
118 }
119
120 intrusive_ptr & operator=(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT
121 {
122 this_type( static_cast< intrusive_ptr && >( rhs ) ).swap(*this);
123 return *this;
124 }
125
126 template<class U> friend class intrusive_ptr;
127
128 template<class U>
129#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
130
131 intrusive_ptr(intrusive_ptr<U> && rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty())
132
133#else
134
135 intrusive_ptr(intrusive_ptr<U> && rhs)
136
137#endif
138 : px( rhs.px )
139 {
140 rhs.px = 0;
141 }
142
143 template<class U>
144 intrusive_ptr & operator=(intrusive_ptr<U> && rhs) BOOST_SP_NOEXCEPT
145 {
146 this_type( static_cast< intrusive_ptr<U> && >( rhs ) ).swap(*this);
147 return *this;
148 }
149
150#endif
151
152 intrusive_ptr & operator=(intrusive_ptr const & rhs)
153 {
154 this_type(rhs).swap(*this);
155 return *this;
156 }
157
158 intrusive_ptr & operator=(T * rhs)
159 {
160 this_type(rhs).swap(*this);
161 return *this;
162 }
163
164 void reset()
165 {
166 this_type().swap( *this );
167 }
168
169 void reset( T * rhs )
170 {
171 this_type( rhs ).swap( *this );
172 }
173
174 void reset( T * rhs, bool add_ref )
175 {
176 this_type( rhs, add_ref ).swap( *this );
177 }
178
179 T * get() const BOOST_SP_NOEXCEPT
180 {
181 return px;
182 }
183
184 T * detach() BOOST_SP_NOEXCEPT
185 {
186 T * ret = px;
187 px = 0;
188 return ret;
189 }
190
191 T & operator*() const BOOST_SP_NOEXCEPT_WITH_ASSERT
192 {
193 BOOST_ASSERT( px != 0 );
194 return *px;
195 }
196
197 T * operator->() const BOOST_SP_NOEXCEPT_WITH_ASSERT
198 {
199 BOOST_ASSERT( px != 0 );
200 return px;
201 }
202
203// implicit conversion to "bool"
204#include <boost/smart_ptr/detail/operator_bool.hpp>
205
206 void swap(intrusive_ptr & rhs) BOOST_SP_NOEXCEPT
207 {
208 T * tmp = px;
209 px = rhs.px;
210 rhs.px = tmp;
211 }
212
213private:
214
215 T * px;
216};
217
218template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
219{
220 return a.get() == b.get();
221}
222
223template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
224{
225 return a.get() != b.get();
226}
227
228template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
229{
230 return a.get() == b;
231}
232
233template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
234{
235 return a.get() != b;
236}
237
238template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
239{
240 return a == b.get();
241}
242
243template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
244{
245 return a != b.get();
246}
247
248#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
249
250// Resolve the ambiguity between our op!= and the one in rel_ops
251
252template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) BOOST_SP_NOEXCEPT
253{
254 return a.get() != b.get();
255}
256
257#endif
258
259#if !defined( BOOST_NO_CXX11_NULLPTR )
260
261template<class T> inline bool operator==( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
262{
263 return p.get() == 0;
264}
265
266template<class T> inline bool operator==( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
267{
268 return p.get() == 0;
269}
270
271template<class T> inline bool operator!=( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
272{
273 return p.get() != 0;
274}
275
276template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
277{
278 return p.get() != 0;
279}
280
281#endif
282
283template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) BOOST_SP_NOEXCEPT
284{
285 return std::less<T *>()(a.get(), b.get());
286}
287
288template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs) BOOST_SP_NOEXCEPT
289{
290 lhs.swap(rhs);
291}
292
293// mem_fn support
294
295template<class T> T * get_pointer(intrusive_ptr<T> const & p) BOOST_SP_NOEXCEPT
296{
297 return p.get();
298}
299
300template<class T, class U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)
301{
302 return static_cast<T *>(p.get());
303}
304
305template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p)
306{
307 return const_cast<T *>(p.get());
308}
309
310template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)
311{
312 return dynamic_cast<T *>(p.get());
313}
314
315// operator<<
316
317#if !defined(BOOST_NO_IOSTREAM)
318
319#if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) && (__GNUC__ < 3) )
320
321template<class Y> std::ostream & operator<< (std::ostream & os, intrusive_ptr<Y> const & p)
322{
323 os << p.get();
324 return os;
325}
326
327#else
328
329// in STLport's no-iostreams mode no iostream symbols can be used
330#ifndef _STLP_NO_IOSTREAMS
331
332# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT)
333// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
334using std::basic_ostream;
335template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
336# else
337template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
338# endif
339{
340 os << p.get();
341 return os;
342}
343
344#endif // _STLP_NO_IOSTREAMS
345
346#endif // __GNUC__ < 3
347
348#endif // !defined(BOOST_NO_IOSTREAM)
349
350// hash_value
351
352template< class T > struct hash;
353
354template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
355{
356 return boost::hash< T* >()( p.get() );
357}
358
359} // namespace boost
360
361#endif // #ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED
362