OSDN Git Service

490810cabf6f190ee88668f477bd3b4c813b6d85
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / bits / shared_ptr.h
1 // shared_ptr and weak_ptr implementation -*- C++ -*-
2
3 // Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library.  This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 // GNU General Public License for more details.
15
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23 // <http://www.gnu.org/licenses/>.
24
25 // GCC Note: Based on files from version 1.32.0 of the Boost library.
26
27 //  shared_count.hpp
28 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
29
30 //  shared_ptr.hpp
31 //  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32 //  Copyright (C) 2001, 2002, 2003 Peter Dimov
33
34 //  weak_ptr.hpp
35 //  Copyright (C) 2001, 2002, 2003 Peter Dimov
36
37 //  enable_shared_from_this.hpp
38 //  Copyright (C) 2002 Peter Dimov
39
40 // Distributed under the Boost Software License, Version 1.0. (See
41 // accompanying file LICENSE_1_0.txt or copy at
42 // http://www.boost.org/LICENSE_1_0.txt)
43
44 /** @file bits/shared_ptr.h
45  *  This is an internal header file, included by other library headers.
46  *  Do not attempt to use it directly. @headername{memory}
47  */
48
49 #ifndef _SHARED_PTR_H
50 #define _SHARED_PTR_H 1
51
52 #include <bits/shared_ptr_base.h>
53
54 namespace std _GLIBCXX_VISIBILITY(default)
55 {
56 _GLIBCXX_BEGIN_NAMESPACE_VERSION
57
58   /**
59    * @addtogroup pointer_abstractions
60    * @{
61    */
62
63   /// 2.2.3.7 shared_ptr I/O
64   template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
65     inline std::basic_ostream<_Ch, _Tr>&
66     operator<<(std::basic_ostream<_Ch, _Tr>& __os,
67                const __shared_ptr<_Tp, _Lp>& __p)
68     {
69       __os << __p.get();
70       return __os;
71     }
72
73   /// 2.2.3.10 shared_ptr get_deleter (experimental)
74   template<typename _Del, typename _Tp, _Lock_policy _Lp>
75     inline _Del*
76     get_deleter(const __shared_ptr<_Tp, _Lp>& __p)
77     {
78 #ifdef __GXX_RTTI
79       return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
80 #else
81       return 0;
82 #endif
83     }
84
85
86   /**
87    *  @brief  A smart pointer with reference-counted copy semantics.
88    *
89    *  The object pointed to is deleted when the last shared_ptr pointing to
90    *  it is destroyed or reset.
91   */
92   template<typename _Tp>
93     class shared_ptr : public __shared_ptr<_Tp>
94     {
95     public:
96       /**
97        *  @brief  Construct an empty %shared_ptr.
98        *  @post   use_count()==0 && get()==0
99        */
100       constexpr shared_ptr()
101       : __shared_ptr<_Tp>() { }
102
103       /**
104        *  @brief  Construct a %shared_ptr that owns the pointer @a __p.
105        *  @param  __p  A pointer that is convertible to element_type*.
106        *  @post   use_count() == 1 && get() == __p
107        *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
108        */
109       template<typename _Tp1>
110         explicit shared_ptr(_Tp1* __p)
111         : __shared_ptr<_Tp>(__p) { }
112
113       /**
114        *  @brief  Construct a %shared_ptr that owns the pointer @a __p
115        *          and the deleter @a __d.
116        *  @param  __p  A pointer.
117        *  @param  __d  A deleter.
118        *  @post   use_count() == 1 && get() == __p
119        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
120        *
121        *  Requirements: _Deleter's copy constructor and destructor must
122        *  not throw
123        *
124        *  __shared_ptr will release __p by calling __d(__p)
125        */
126       template<typename _Tp1, typename _Deleter>
127         shared_ptr(_Tp1* __p, _Deleter __d)
128         : __shared_ptr<_Tp>(__p, __d) { }
129
130       /**
131        *  @brief  Construct a %shared_ptr that owns a null pointer
132        *          and the deleter @a __d.
133        *  @param  __p  A null pointer constant.
134        *  @param  __d  A deleter.
135        *  @post   use_count() == 1 && get() == __p
136        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
137        *
138        *  Requirements: _Deleter's copy constructor and destructor must
139        *  not throw
140        *
141        *  The last owner will call __d(__p)
142        */
143       template<typename _Deleter>
144         shared_ptr(nullptr_t __p, _Deleter __d)
145         : __shared_ptr<_Tp>(__p, __d) { }
146
147       /**
148        *  @brief  Construct a %shared_ptr that owns the pointer @a __p
149        *          and the deleter @a __d.
150        *  @param  __p  A pointer.
151        *  @param  __d  A deleter.
152        *  @param  __a  An allocator.
153        *  @post   use_count() == 1 && get() == __p
154        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
155        *
156        *  Requirements: _Deleter's copy constructor and destructor must
157        *  not throw _Alloc's copy constructor and destructor must not
158        *  throw.
159        *
160        *  __shared_ptr will release __p by calling __d(__p)
161        */
162       template<typename _Tp1, typename _Deleter, typename _Alloc>
163         shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
164         : __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
165
166       /**
167        *  @brief  Construct a %shared_ptr that owns a null pointer
168        *          and the deleter @a __d.
169        *  @param  __p  A null pointer constant.
170        *  @param  __d  A deleter.
171        *  @param  __a  An allocator.
172        *  @post   use_count() == 1 && get() == __p
173        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
174        *
175        *  Requirements: _Deleter's copy constructor and destructor must
176        *  not throw _Alloc's copy constructor and destructor must not
177        *  throw.
178        *
179        *  The last owner will call __d(__p)
180        */
181       template<typename _Deleter, typename _Alloc>
182         shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
183         : __shared_ptr<_Tp>(__p, __d, std::move(__a)) { }
184
185       // Aliasing constructor
186
187       /**
188        *  @brief  Constructs a %shared_ptr instance that stores @a __p
189        *          and shares ownership with @a __r.
190        *  @param  __r  A %shared_ptr.
191        *  @param  __p  A pointer that will remain valid while @a *__r is valid.
192        *  @post   get() == __p && use_count() == __r.use_count()
193        *
194        *  This can be used to construct a @c shared_ptr to a sub-object
195        *  of an object managed by an existing @c shared_ptr.
196        *
197        * @code
198        * shared_ptr< pair<int,int> > pii(new pair<int,int>());
199        * shared_ptr<int> pi(pii, &pii->first);
200        * assert(pii.use_count() == 2);
201        * @endcode
202        */
203       template<typename _Tp1>
204         shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p)
205         : __shared_ptr<_Tp>(__r, __p) { }
206
207       /**
208        *  @brief  If @a __r is empty, constructs an empty %shared_ptr;
209        *          otherwise construct a %shared_ptr that shares ownership
210        *          with @a __r.
211        *  @param  __r  A %shared_ptr.
212        *  @post   get() == __r.get() && use_count() == __r.use_count()
213        */
214       template<typename _Tp1, typename = typename
215                std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
216         shared_ptr(const shared_ptr<_Tp1>& __r)
217         : __shared_ptr<_Tp>(__r) { }
218
219       /**
220        *  @brief  Move-constructs a %shared_ptr instance from @a __r.
221        *  @param  __r  A %shared_ptr rvalue.
222        *  @post   *this contains the old value of @a __r, @a __r is empty.
223        */
224       shared_ptr(shared_ptr&& __r)
225       : __shared_ptr<_Tp>(std::move(__r)) { }
226
227       /**
228        *  @brief  Move-constructs a %shared_ptr instance from @a __r.
229        *  @param  __r  A %shared_ptr rvalue.
230        *  @post   *this contains the old value of @a __r, @a __r is empty.
231        */
232       template<typename _Tp1, typename = typename
233                std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
234         shared_ptr(shared_ptr<_Tp1>&& __r)
235         : __shared_ptr<_Tp>(std::move(__r)) { }
236
237       /**
238        *  @brief  Constructs a %shared_ptr that shares ownership with @a __r
239        *          and stores a copy of the pointer stored in @a __r.
240        *  @param  __r  A weak_ptr.
241        *  @post   use_count() == __r.use_count()
242        *  @throw  bad_weak_ptr when __r.expired(),
243        *          in which case the constructor has no effect.
244        */
245       template<typename _Tp1>
246         explicit shared_ptr(const weak_ptr<_Tp1>& __r)
247         : __shared_ptr<_Tp>(__r) { }
248
249 #if _GLIBCXX_USE_DEPRECATED
250       template<typename _Tp1>
251         shared_ptr(std::auto_ptr<_Tp1>&& __r)
252         : __shared_ptr<_Tp>(std::move(__r)) { }
253 #endif
254
255       template<typename _Tp1, typename _Del>
256         shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
257         : __shared_ptr<_Tp>(std::move(__r)) { }
258
259       /**
260        *  @brief  Construct an empty %shared_ptr.
261        *  @param  __p  A null pointer constant.
262        *  @post   use_count() == 0 && get() == nullptr
263        */
264       constexpr shared_ptr(nullptr_t __p)
265       : __shared_ptr<_Tp>(__p) { }
266
267       template<typename _Tp1>
268         shared_ptr&
269         operator=(const shared_ptr<_Tp1>& __r) // never throws
270         {
271           this->__shared_ptr<_Tp>::operator=(__r);
272           return *this;
273         }
274
275 #if _GLIBCXX_USE_DEPRECATED
276       template<typename _Tp1>
277         shared_ptr&
278         operator=(std::auto_ptr<_Tp1>&& __r)
279         {
280           this->__shared_ptr<_Tp>::operator=(std::move(__r));
281           return *this;
282         }
283 #endif
284
285       shared_ptr&
286       operator=(shared_ptr&& __r)
287       {
288         this->__shared_ptr<_Tp>::operator=(std::move(__r));
289         return *this;
290       }
291
292       template<class _Tp1>
293         shared_ptr&
294         operator=(shared_ptr<_Tp1>&& __r)
295         {
296           this->__shared_ptr<_Tp>::operator=(std::move(__r));
297           return *this;
298         }
299
300       template<typename _Tp1, typename _Del>
301         shared_ptr&
302         operator=(std::unique_ptr<_Tp1, _Del>&& __r)
303         {
304           this->__shared_ptr<_Tp>::operator=(std::move(__r));
305           return *this;
306         }
307
308     private:
309       // This constructor is non-standard, it is used by allocate_shared.
310       template<typename _Alloc, typename... _Args>
311         shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
312                    _Args&&... __args)
313         : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
314         { }
315
316       template<typename _Tp1, typename _Alloc, typename... _Args>
317         friend shared_ptr<_Tp1>
318         allocate_shared(const _Alloc& __a, _Args&&... __args);
319     };
320
321   // 20.8.13.2.7 shared_ptr comparisons
322   template<typename _Tp1, typename _Tp2>
323     inline bool
324     operator==(const shared_ptr<_Tp1>& __a,
325                const shared_ptr<_Tp2>& __b) noexcept
326     { return __a.get() == __b.get(); }
327
328   template<typename _Tp>
329     inline bool
330     operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
331     { return !__a; }
332
333   template<typename _Tp>
334     inline bool
335     operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
336     { return !__a; }
337
338   template<typename _Tp1, typename _Tp2>
339     inline bool
340     operator!=(const shared_ptr<_Tp1>& __a,
341                const shared_ptr<_Tp2>& __b) noexcept
342     { return __a.get() != __b.get(); }
343
344   template<typename _Tp>
345     inline bool
346     operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
347     { return (bool)__a; }
348
349   template<typename _Tp>
350     inline bool
351     operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
352     { return (bool)__a; }
353
354   template<typename _Tp1, typename _Tp2>
355     inline bool
356     operator<(const shared_ptr<_Tp1>& __a,
357               const shared_ptr<_Tp2>& __b) noexcept
358     {
359       typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
360       return std::less<_CT>()(__a.get(), __b.get());
361     }
362
363   template<typename _Tp>
364     inline bool
365     operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
366     { return std::less<_Tp*>()(__a.get(), nullptr); }
367
368   template<typename _Tp>
369     inline bool
370     operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
371     { return std::less<_Tp*>()(nullptr, __a.get()); }
372
373   template<typename _Tp1, typename _Tp2>
374     inline bool
375     operator<=(const shared_ptr<_Tp1>& __a,
376                const shared_ptr<_Tp2>& __b) noexcept
377     { return !(__b < __a); }
378
379   template<typename _Tp>
380     inline bool
381     operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
382     { return !(nullptr < __a); }
383
384   template<typename _Tp>
385     inline bool
386     operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
387     { return !(__a < nullptr); }
388
389   template<typename _Tp1, typename _Tp2>
390     inline bool
391     operator>(const shared_ptr<_Tp1>& __a,
392               const shared_ptr<_Tp2>& __b) noexcept
393     { return (__b < __a); }
394
395   template<typename _Tp>
396     inline bool
397     operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
398     { return std::less<_Tp*>()(nullptr, __a.get()); }
399
400   template<typename _Tp>
401     inline bool
402     operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
403     { return std::less<_Tp*>()(__a.get(), nullptr); }
404
405   template<typename _Tp1, typename _Tp2>
406     inline bool
407     operator>=(const shared_ptr<_Tp1>& __a,
408                const shared_ptr<_Tp2>& __b) noexcept
409     { return !(__a < __b); }
410
411   template<typename _Tp>
412     inline bool
413     operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
414     { return !(__a < nullptr); }
415
416   template<typename _Tp>
417     inline bool
418     operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
419     { return !(nullptr < __a); }
420
421   template<typename _Tp>
422     struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
423     { };
424
425   // 20.8.13.2.9 shared_ptr specialized algorithms.
426   template<typename _Tp>
427     inline void
428     swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b)
429     { __a.swap(__b); }
430
431   // 20.8.13.2.10 shared_ptr casts.
432   template<typename _Tp, typename _Tp1>
433     inline shared_ptr<_Tp>
434     static_pointer_cast(const shared_ptr<_Tp1>& __r)
435     { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
436
437   template<typename _Tp, typename _Tp1>
438     inline shared_ptr<_Tp>
439     const_pointer_cast(const shared_ptr<_Tp1>& __r)
440     { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
441
442   template<typename _Tp, typename _Tp1>
443     inline shared_ptr<_Tp>
444     dynamic_pointer_cast(const shared_ptr<_Tp1>& __r)
445     {
446       if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
447         return shared_ptr<_Tp>(__r, __p);
448       return shared_ptr<_Tp>();
449     }
450
451
452   /**
453    *  @brief  A smart pointer with weak semantics.
454    *
455    *  With forwarding constructors and assignment operators.
456    */
457   template<typename _Tp>
458     class weak_ptr : public __weak_ptr<_Tp>
459     {
460     public:
461       constexpr weak_ptr()
462       : __weak_ptr<_Tp>() { }
463
464       template<typename _Tp1, typename = typename
465                std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
466         weak_ptr(const weak_ptr<_Tp1>& __r)
467         : __weak_ptr<_Tp>(__r) { }
468
469       template<typename _Tp1, typename = typename
470                std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
471         weak_ptr(const shared_ptr<_Tp1>& __r)
472         : __weak_ptr<_Tp>(__r) { }
473
474       template<typename _Tp1>
475         weak_ptr&
476         operator=(const weak_ptr<_Tp1>& __r) // never throws
477         {
478           this->__weak_ptr<_Tp>::operator=(__r);
479           return *this;
480         }
481
482       template<typename _Tp1>
483         weak_ptr&
484         operator=(const shared_ptr<_Tp1>& __r) // never throws
485         {
486           this->__weak_ptr<_Tp>::operator=(__r);
487           return *this;
488         }
489
490       shared_ptr<_Tp>
491       lock() const // never throws
492       {
493 #ifdef __GTHREADS
494         if (this->expired())
495           return shared_ptr<_Tp>();
496
497         __try
498           {
499             return shared_ptr<_Tp>(*this);
500           }
501         __catch(const bad_weak_ptr&)
502           {
503             return shared_ptr<_Tp>();
504           }
505 #else
506         return this->expired() ? shared_ptr<_Tp>() : shared_ptr<_Tp>(*this);
507 #endif
508       }
509     };
510
511   // 20.8.13.3.7 weak_ptr specialized algorithms.
512   template<typename _Tp>
513     inline void
514     swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b)
515     { __a.swap(__b); }
516
517
518   /// Primary template owner_less
519   template<typename _Tp>
520     struct owner_less;
521
522   /// Partial specialization of owner_less for shared_ptr.
523   template<typename _Tp>
524     struct owner_less<shared_ptr<_Tp>>
525     : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
526     { };
527
528   /// Partial specialization of owner_less for weak_ptr.
529   template<typename _Tp>
530     struct owner_less<weak_ptr<_Tp>>
531     : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
532     { };
533
534   /**
535    *  @brief Base class allowing use of member function shared_from_this.
536    */
537   template<typename _Tp>
538     class enable_shared_from_this
539     {
540     protected:
541       constexpr enable_shared_from_this() { }
542
543       enable_shared_from_this(const enable_shared_from_this&) { }
544
545       enable_shared_from_this&
546       operator=(const enable_shared_from_this&)
547       { return *this; }
548
549       ~enable_shared_from_this() { }
550
551     public:
552       shared_ptr<_Tp>
553       shared_from_this()
554       { return shared_ptr<_Tp>(this->_M_weak_this); }
555
556       shared_ptr<const _Tp>
557       shared_from_this() const
558       { return shared_ptr<const _Tp>(this->_M_weak_this); }
559
560     private:
561       template<typename _Tp1>
562         void
563         _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const
564         { _M_weak_this._M_assign(__p, __n); }
565
566       template<typename _Tp1>
567         friend void
568         __enable_shared_from_this_helper(const __shared_count<>& __pn,
569                                          const enable_shared_from_this* __pe,
570                                          const _Tp1* __px)
571         {
572           if (__pe != 0)
573             __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
574         }
575
576       mutable weak_ptr<_Tp>  _M_weak_this;
577     };
578
579   /**
580    *  @brief  Create an object that is owned by a shared_ptr.
581    *  @param  __a     An allocator.
582    *  @param  __args  Arguments for the @a _Tp object's constructor.
583    *  @return A shared_ptr that owns the newly created object.
584    *  @throw  An exception thrown from @a _Alloc::allocate or from the
585    *          constructor of @a _Tp.
586    *
587    *  A copy of @a __a will be used to allocate memory for the shared_ptr
588    *  and the new object.
589    */
590   template<typename _Tp, typename _Alloc, typename... _Args>
591     inline shared_ptr<_Tp>
592     allocate_shared(const _Alloc& __a, _Args&&... __args)
593     {
594       return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a,
595                              std::forward<_Args>(__args)...);
596     }
597
598   /**
599    *  @brief  Create an object that is owned by a shared_ptr.
600    *  @param  __args  Arguments for the @a _Tp object's constructor.
601    *  @return A shared_ptr that owns the newly created object.
602    *  @throw  std::bad_alloc, or an exception thrown from the
603    *          constructor of @a _Tp.
604    */
605   template<typename _Tp, typename... _Args>
606     inline shared_ptr<_Tp>
607     make_shared(_Args&&... __args)
608     {
609       typedef typename std::remove_const<_Tp>::type _Tp_nc;
610       return allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
611                                   std::forward<_Args>(__args)...);
612     }
613
614   /// std::hash specialization for shared_ptr.
615   template<typename _Tp>
616     struct hash<shared_ptr<_Tp>>
617     : public std::unary_function<shared_ptr<_Tp>, size_t>
618     {
619       size_t
620       operator()(const shared_ptr<_Tp>& __s) const
621       { return std::hash<_Tp*>()(__s.get()); }
622     };
623
624   // @} group pointer_abstractions
625
626 _GLIBCXX_END_NAMESPACE_VERSION
627 } // namespace
628
629 #endif // _SHARED_PTR_H