OSDN Git Service

b8083e405c893d74363cd1d29f40682e5e33255f
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / bits / shared_ptr_base.h
1 // shared_ptr and weak_ptr implementation details -*- C++ -*-
2
3 // Copyright (C) 2007, 2008, 2009 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_base.h
45  *  This is an internal header file, included by other library headers.
46  *  You should not attempt to use it directly.
47  */
48
49 #ifndef _SHARED_PTR_BASE_H
50 #define _SHARED_PTR_BASE_H 1
51
52 _GLIBCXX_BEGIN_NAMESPACE(std)
53
54   // Forward declarations.
55   template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
56     class __shared_ptr;
57
58   template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
59     class __weak_ptr;
60
61   template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
62     class __enable_shared_from_this;
63
64   template<typename _Tp>
65     class shared_ptr;
66
67   template<typename _Tp>
68     class weak_ptr;
69
70   template<typename _Tp>
71     struct owner_less;
72
73   template<typename _Tp>
74     class enable_shared_from_this;
75
76   template<_Lock_policy _Lp = __default_lock_policy>
77     class __weak_count;
78
79   template<_Lock_policy _Lp = __default_lock_policy>
80     class __shared_count;
81
82
83   // Counted ptr with no deleter or allocator support
84   template<typename _Ptr, _Lock_policy _Lp>
85     class _Sp_counted_ptr : public _Sp_counted_base<_Lp>
86     {
87     public:
88       _Sp_counted_ptr(_Ptr __p)
89       : _M_ptr(__p) { }
90
91       virtual void
92       _M_dispose() // nothrow
93       { delete _M_ptr; }
94
95       virtual void
96       _M_destroy() // nothrow
97       { delete this; }
98
99       virtual void*
100       _M_get_deleter(const std::type_info& __ti)
101       { return 0; }
102
103       _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
104       _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
105
106     protected:
107       _Ptr             _M_ptr;  // copy constructor must not throw
108     };
109
110   // Support for custom deleter and/or allocator
111   template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
112     class _Sp_counted_deleter : public _Sp_counted_ptr<_Ptr, _Lp>
113     {
114       typedef typename _Alloc::template
115           rebind<_Sp_counted_deleter>::other _My_alloc_type;
116
117       // Helper class that stores the Deleter and also acts as an allocator.
118       // Used to dispose of the owned pointer and the internal refcount
119       // Requires that copies of _Alloc can free each other's memory.
120       struct _My_Deleter
121       : public _My_alloc_type    // copy constructor must not throw
122       {
123         _Deleter _M_del;         // copy constructor must not throw
124         _My_Deleter(_Deleter __d, const _Alloc& __a)
125           : _My_alloc_type(__a), _M_del(__d) { }
126       };
127
128     protected:
129       typedef _Sp_counted_ptr<_Ptr, _Lp> _Base_type;
130
131     public:
132       // __d(__p) must not throw.
133       _Sp_counted_deleter(_Ptr __p, _Deleter __d)
134       : _Base_type(__p), _M_del(__d, _Alloc()) { }
135
136       // __d(__p) must not throw.
137       _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a)
138       : _Base_type(__p), _M_del(__d, __a) { }
139
140       virtual void
141       _M_dispose() // nothrow
142       { _M_del._M_del(_Base_type::_M_ptr); }
143
144       virtual void
145       _M_destroy() // nothrow
146       {
147         _My_alloc_type __a(_M_del);
148         this->~_Sp_counted_deleter();
149         __a.deallocate(this, 1);
150       }
151
152       virtual void*
153       _M_get_deleter(const std::type_info& __ti)
154       { return __ti == typeid(_Deleter) ? &_M_del._M_del : 0; }
155
156     protected:
157       _My_Deleter      _M_del;  // copy constructor must not throw
158     };
159
160   // helpers for make_shared / allocate_shared
161
162   template<typename _Tp>
163     struct _Sp_destroy_inplace
164     {
165       void operator()(_Tp* __p) const { if (__p) __p->~_Tp(); }
166     };
167
168   struct _Sp_make_shared_tag { };
169
170   template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
171     class _Sp_counted_ptr_inplace
172     : public _Sp_counted_deleter<_Tp*, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp>
173     {
174       typedef _Sp_counted_deleter<_Tp*, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp>
175         _Base_type;
176
177     public:
178       _Sp_counted_ptr_inplace(_Alloc __a)
179       : _Base_type(static_cast<_Tp*>(0), _Sp_destroy_inplace<_Tp>(), __a)
180       , _M_storage()
181       {
182         void* __p = &_M_storage;
183         ::new (__p) _Tp();  // might throw
184         _Base_type::_Base_type::_M_ptr = static_cast<_Tp*>(__p);
185       }
186
187       template<typename... _Args>
188         _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
189         : _Base_type(static_cast<_Tp*>(0), _Sp_destroy_inplace<_Tp>(), __a)
190         , _M_storage()
191         {
192           void* __p = &_M_storage;
193           ::new (__p) _Tp(std::forward<_Args>(__args)...);  // might throw
194           _Base_type::_Base_type::_M_ptr = static_cast<_Tp*>(__p);
195         }
196
197       // Override because the allocator needs to know the dynamic type
198       virtual void
199       _M_destroy() // nothrow
200       {
201         typedef typename _Alloc::template
202             rebind<_Sp_counted_ptr_inplace>::other _My_alloc_type;
203         _My_alloc_type __a(_Base_type::_M_del);
204         this->~_Sp_counted_ptr_inplace();
205         __a.deallocate(this, 1);
206       }
207
208       // Sneaky trick so __shared_ptr can get the managed pointer
209       virtual void*
210       _M_get_deleter(const std::type_info& __ti)
211       {
212         return __ti == typeid(_Sp_make_shared_tag)
213                ? static_cast<void*>(&_M_storage)
214                : _Base_type::_M_get_deleter(__ti);
215       }
216
217     private:
218       typename aligned_storage<sizeof(_Tp), alignment_of<_Tp>::value>::type
219         _M_storage;
220     };
221
222   template<_Lock_policy _Lp>
223     class __shared_count
224     {
225     public:
226       __shared_count() : _M_pi(0) // nothrow
227       { }
228
229       template<typename _Ptr>
230         __shared_count(_Ptr __p) : _M_pi(0)
231         {
232           __try
233             {
234               _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
235             }
236           __catch(...)
237             {
238               delete __p;
239               __throw_exception_again;
240             }
241         }
242
243       template<typename _Ptr, typename _Deleter>
244         __shared_count(_Ptr __p, _Deleter __d) : _M_pi(0)
245         {
246           // The allocator's value_type doesn't matter, will rebind it anyway.
247           typedef std::allocator<int> _Alloc;
248           typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
249           typedef std::allocator<_Sp_cd_type> _Alloc2;
250           _Alloc2 __a2;
251           __try
252             {
253               _M_pi = __a2.allocate(1);
254               ::new(static_cast<void*>(_M_pi)) _Sp_cd_type(__p, __d);
255             }
256           __catch(...)
257             {
258               __d(__p); // Call _Deleter on __p.
259               if (_M_pi)
260                 __a2.deallocate(static_cast<_Sp_cd_type*>(_M_pi), 1);
261               __throw_exception_again;
262             }
263         }
264
265       template<typename _Ptr, typename _Deleter, typename _Alloc>
266         __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
267         {
268           typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
269           typedef typename _Alloc::template rebind<_Sp_cd_type>::other _Alloc2;
270           _Alloc2 __a2(__a);
271           __try
272             {
273               _M_pi = __a2.allocate(1);
274               ::new(static_cast<void*>(_M_pi)) _Sp_cd_type(__p, __d, __a);
275             }
276           __catch(...)
277             {
278               __d(__p); // Call _Deleter on __p.
279               if (_M_pi)
280                 __a2.deallocate(static_cast<_Sp_cd_type*>(_M_pi), 1);
281               __throw_exception_again;
282             }
283         }
284
285       template<typename _Tp, typename _Alloc, typename... _Args>
286         __shared_count(_Sp_make_shared_tag, _Tp*, _Alloc __a, _Args&&... __args)
287         : _M_pi(0)
288         {
289           typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
290           typedef typename _Alloc::template rebind<_Sp_cp_type>::other _Alloc2;
291           _Alloc2 __a2(__a);
292           __try
293             {
294               _M_pi = __a2.allocate(1);
295               ::new(static_cast<void*>(_M_pi)) _Sp_cp_type(__a,
296                     std::forward<_Args>(__args)...);
297             }
298           __catch(...)
299             {
300               if (_M_pi)
301                 __a2.deallocate(static_cast<_Sp_cp_type*>(_M_pi), 1);
302               __throw_exception_again;
303             }
304         }
305
306 #if _GLIBCXX_DEPRECATED
307       // Special case for auto_ptr<_Tp> to provide the strong guarantee.
308       template<typename _Tp>
309         explicit __shared_count(std::auto_ptr<_Tp>&& __r)
310         : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
311         { __r.release(); }
312 #endif
313
314       // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
315       template<typename _Tp, typename _Del>
316         explicit __shared_count(std::unique_ptr<_Tp, _Del>&& __r)
317         : _M_pi(_S_create_from_up(std::move(__r)))
318         { __r.release(); }
319
320       // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
321       explicit __shared_count(const __weak_count<_Lp>& __r);
322
323       ~__shared_count() // nothrow
324       {
325         if (_M_pi != 0)
326           _M_pi->_M_release();
327       }
328
329       __shared_count(const __shared_count& __r)
330       : _M_pi(__r._M_pi) // nothrow
331       {
332         if (_M_pi != 0)
333           _M_pi->_M_add_ref_copy();
334       }
335
336       __shared_count&
337       operator=(const __shared_count& __r) // nothrow
338       {
339         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
340         if (__tmp != _M_pi)
341           {
342             if (__tmp != 0)
343               __tmp->_M_add_ref_copy();
344             if (_M_pi != 0)
345               _M_pi->_M_release();
346             _M_pi = __tmp;
347           }
348         return *this;
349       }
350
351       void
352       _M_swap(__shared_count& __r) // nothrow
353       {
354         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
355         __r._M_pi = _M_pi;
356         _M_pi = __tmp;
357       }
358
359       long
360       _M_get_use_count() const // nothrow
361       { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
362
363       bool
364       _M_unique() const // nothrow
365       { return this->_M_get_use_count() == 1; }
366
367       void*
368       _M_get_deleter(const std::type_info& __ti) const
369       { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; }
370
371       bool
372       _M_less(const __shared_count& __rhs) const
373       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
374
375       bool
376       _M_less(const __weak_count<_Lp>& __rhs) const
377       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
378
379       // Friend function injected into enclosing namespace and found by ADL
380       friend inline bool
381       operator==(const __shared_count& __a, const __shared_count& __b)
382       { return __a._M_pi == __b._M_pi; }
383
384     private:
385       friend class __weak_count<_Lp>;
386
387       template<typename _Tp, typename _Del>
388         static _Sp_counted_base<_Lp>*
389         _S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r,
390           typename std::enable_if<!std::is_reference<_Del>::value>::type* = 0)
391         {
392           return new _Sp_counted_deleter<_Tp*, _Del, std::allocator<_Tp>,
393             _Lp>(__r.get(), __r.get_deleter());
394         }
395
396       template<typename _Tp, typename _Del>
397         static _Sp_counted_base<_Lp>*
398         _S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r,
399           typename std::enable_if<std::is_reference<_Del>::value>::type* = 0)
400         {
401           typedef typename std::remove_reference<_Del>::type _Del1;
402           typedef std::reference_wrapper<_Del1> _Del2;
403           return new _Sp_counted_deleter<_Tp*, _Del2, std::allocator<_Tp>,
404             _Lp>(__r.get(), std::ref(__r.get_deleter()));
405         }
406
407       _Sp_counted_base<_Lp>*  _M_pi;
408     };
409
410
411   template<_Lock_policy _Lp>
412     class __weak_count
413     {
414     public:
415       __weak_count() : _M_pi(0) // nothrow
416       { }
417
418       __weak_count(const __shared_count<_Lp>& __r) : _M_pi(__r._M_pi) // nothrow
419       {
420         if (_M_pi != 0)
421           _M_pi->_M_weak_add_ref();
422       }
423
424       __weak_count(const __weak_count<_Lp>& __r) : _M_pi(__r._M_pi) // nothrow
425       {
426         if (_M_pi != 0)
427           _M_pi->_M_weak_add_ref();
428       }
429
430       ~__weak_count() // nothrow
431       {
432         if (_M_pi != 0)
433           _M_pi->_M_weak_release();
434       }
435
436       __weak_count<_Lp>&
437       operator=(const __shared_count<_Lp>& __r) // nothrow
438       {
439         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
440         if (__tmp != 0)
441           __tmp->_M_weak_add_ref();
442         if (_M_pi != 0)
443           _M_pi->_M_weak_release();
444         _M_pi = __tmp;
445         return *this;
446       }
447
448       __weak_count<_Lp>&
449       operator=(const __weak_count<_Lp>& __r) // nothrow
450       {
451         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
452         if (__tmp != 0)
453           __tmp->_M_weak_add_ref();
454         if (_M_pi != 0)
455           _M_pi->_M_weak_release();
456         _M_pi = __tmp;
457         return *this;
458       }
459
460       void
461       _M_swap(__weak_count<_Lp>& __r) // nothrow
462       {
463         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
464         __r._M_pi = _M_pi;
465         _M_pi = __tmp;
466       }
467
468       long
469       _M_get_use_count() const // nothrow
470       { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
471
472       bool
473       _M_less(const __weak_count& __rhs) const
474       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
475
476       bool
477       _M_less(const __shared_count<_Lp>& __rhs) const
478       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
479
480       // Friend function injected into enclosing namespace and found by ADL
481       friend inline bool
482       operator==(const __weak_count& __a, const __weak_count& __b)
483       { return __a._M_pi == __b._M_pi; }
484
485     private:
486       friend class __shared_count<_Lp>;
487
488       _Sp_counted_base<_Lp>*  _M_pi;
489     };
490
491   // Now that __weak_count is defined we can define this constructor:
492   template<_Lock_policy _Lp>
493     inline __shared_count<_Lp>:: __shared_count(const __weak_count<_Lp>& __r)
494     : _M_pi(__r._M_pi)
495     {
496       if (_M_pi != 0)
497         _M_pi->_M_add_ref_lock();
498       else
499         __throw_bad_weak_ptr();
500     }
501
502
503   // Support for enable_shared_from_this.
504
505   // Friend of __enable_shared_from_this.
506   template<_Lock_policy _Lp, typename _Tp1, typename _Tp2>
507     void
508     __enable_shared_from_this_helper(const __shared_count<_Lp>&,
509                                      const __enable_shared_from_this<_Tp1,
510                                      _Lp>*, const _Tp2*);
511
512   // Friend of enable_shared_from_this.
513   template<typename _Tp1, typename _Tp2>
514     void
515     __enable_shared_from_this_helper(const __shared_count<>&,
516                                      const enable_shared_from_this<_Tp1>*,
517                                      const _Tp2*);
518
519   template<_Lock_policy _Lp>
520     inline void
521     __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...)
522     { }
523
524
525   template<typename _Tp, _Lock_policy _Lp>
526     class __shared_ptr
527     {
528     public:
529       typedef _Tp   element_type;
530
531       __shared_ptr() : _M_ptr(0), _M_refcount() // never throws
532       { }
533
534       template<typename _Tp1>
535         explicit __shared_ptr(_Tp1* __p) : _M_ptr(__p), _M_refcount(__p)
536         {
537           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
538           // __glibcxx_function_requires(_CompleteConcept<_Tp1*>)
539           __enable_shared_from_this_helper(_M_refcount, __p, __p);
540         }
541
542       template<typename _Tp1, typename _Deleter>
543         __shared_ptr(_Tp1* __p, _Deleter __d)
544         : _M_ptr(__p), _M_refcount(__p, __d)
545         {
546           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
547           // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
548           __enable_shared_from_this_helper(_M_refcount, __p, __p);
549         }
550
551       template<typename _Tp1, typename _Deleter, typename _Alloc>
552         __shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a)
553         : _M_ptr(__p), _M_refcount(__p, __d, __a)
554         {
555           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
556           // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
557           __enable_shared_from_this_helper(_M_refcount, __p, __p);
558         }
559
560       template<typename _Tp1>
561         __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p)
562         : _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
563         { }
564
565       //  generated copy constructor, assignment, destructor are fine.
566
567       template<typename _Tp1>
568         __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r)
569         : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
570         { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) }
571
572       __shared_ptr(__shared_ptr&& __r)
573       : _M_ptr(__r._M_ptr), _M_refcount() // never throws
574       {
575         _M_refcount._M_swap(__r._M_refcount);
576         __r._M_ptr = 0;
577       }
578
579       template<typename _Tp1>
580         __shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r)
581         : _M_ptr(__r._M_ptr), _M_refcount() // never throws
582         {
583           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
584           _M_refcount._M_swap(__r._M_refcount);
585           __r._M_ptr = 0;
586         }
587
588       template<typename _Tp1>
589         explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
590         : _M_refcount(__r._M_refcount) // may throw
591         {
592           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
593
594           // It is now safe to copy __r._M_ptr, as
595           // _M_refcount(__r._M_refcount) did not throw.
596           _M_ptr = __r._M_ptr;
597         }
598
599       template<typename _Tp1, typename _Del>
600         explicit __shared_ptr(const std::unique_ptr<_Tp1, _Del>&) = delete;
601
602       // If an exception is thrown this constructor has no effect.
603       template<typename _Tp1, typename _Del>
604         explicit __shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
605         : _M_ptr(__r.get()), _M_refcount()
606         {
607           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
608           _Tp1* __tmp = __r.get();
609           _M_refcount = __shared_count<_Lp>(std::move(__r));
610           __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
611         }
612
613 #if _GLIBCXX_DEPRECATED
614       // Postcondition: use_count() == 1 and __r.get() == 0
615       template<typename _Tp1>
616         explicit __shared_ptr(std::auto_ptr<_Tp1>&& __r)
617         : _M_ptr(__r.get()), _M_refcount()
618         {
619           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
620           // TODO requires _Tp1 is complete, delete __r.release() well-formed
621           _Tp1* __tmp = __r.get();
622           _M_refcount = __shared_count<_Lp>(std::move(__r));
623           __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
624         }
625 #endif
626
627       template<typename _Tp1>
628         __shared_ptr&
629         operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws
630         {
631           _M_ptr = __r._M_ptr;
632           _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
633           return *this;
634         }
635
636 #if _GLIBCXX_DEPRECATED
637       template<typename _Tp1>
638         __shared_ptr&
639         operator=(std::auto_ptr<_Tp1>&& __r)
640         {
641           __shared_ptr(std::move(__r)).swap(*this);
642           return *this;
643         }
644 #endif
645
646       __shared_ptr&
647       operator=(__shared_ptr&& __r)
648       {
649         __shared_ptr(std::move(__r)).swap(*this);
650         return *this;
651       }
652
653       template<class _Tp1>
654         __shared_ptr&
655         operator=(__shared_ptr<_Tp1, _Lp>&& __r)
656         {
657           __shared_ptr(std::move(__r)).swap(*this);
658           return *this;
659         }
660
661       template<typename _Tp1, typename _Del>
662         __shared_ptr&
663         operator=(const std::unique_ptr<_Tp1, _Del>& __r) = delete;
664
665       template<typename _Tp1, typename _Del>
666         __shared_ptr&
667         operator=(std::unique_ptr<_Tp1, _Del>&& __r)
668         {
669           __shared_ptr(std::move(__r)).swap(*this);
670           return *this;
671         }
672
673       void
674       reset() // never throws
675       { __shared_ptr().swap(*this); }
676
677       template<typename _Tp1>
678         void
679         reset(_Tp1* __p) // _Tp1 must be complete.
680         {
681           // Catch self-reset errors.
682           _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr);
683           __shared_ptr(__p).swap(*this);
684         }
685
686       template<typename _Tp1, typename _Deleter>
687         void
688         reset(_Tp1* __p, _Deleter __d)
689         { __shared_ptr(__p, __d).swap(*this); }
690
691       template<typename _Tp1, typename _Deleter, typename _Alloc>
692         void
693         reset(_Tp1* __p, _Deleter __d, const _Alloc& __a)
694         { __shared_ptr(__p, __d, __a).swap(*this); }
695
696       // Allow class instantiation when _Tp is [cv-qual] void.
697       typename std::add_lvalue_reference<_Tp>::type
698       operator*() const // never throws
699       {
700         _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
701         return *_M_ptr;
702       }
703
704       _Tp*
705       operator->() const // never throws
706       {
707         _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
708         return _M_ptr;
709       }
710
711       _Tp*
712       get() const // never throws
713       { return _M_ptr; }
714
715       explicit operator bool() const // never throws
716       { return _M_ptr == 0 ? false : true; }
717
718       bool
719       unique() const // never throws
720       { return _M_refcount._M_unique(); }
721
722       long
723       use_count() const // never throws
724       { return _M_refcount._M_get_use_count(); }
725
726       void
727       swap(__shared_ptr<_Tp, _Lp>& __other) // never throws
728       {
729         std::swap(_M_ptr, __other._M_ptr);
730         _M_refcount._M_swap(__other._M_refcount);
731       }
732
733       template<typename _Tp1>
734         bool
735         owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
736         { return _M_refcount._M_less(__rhs._M_refcount); }
737
738       template<typename _Tp1>
739         bool
740         owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
741         { return _M_refcount._M_less(__rhs._M_refcount); }
742
743     protected:
744       // This constructor is non-standard, it is used by allocate_shared.
745       template<typename _Alloc, typename... _Args>
746         __shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args)
747         : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
748                                 std::forward<_Args>(__args)...)
749         {
750           // _M_ptr needs to point to the newly constructed object.
751           // This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
752           void* __p = _M_refcount._M_get_deleter(typeid(__tag));
753           _M_ptr = static_cast<_Tp*>(__p);
754           __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
755         }
756
757       template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
758                typename... _Args>
759         friend __shared_ptr<_Tp1, _Lp1>
760         __allocate_shared(_Alloc __a, _Args&&... __args);
761
762     private:
763       void*
764       _M_get_deleter(const std::type_info& __ti) const
765       { return _M_refcount._M_get_deleter(__ti); }
766
767       template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
768       template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
769
770       template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
771         friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&);
772
773       _Tp*                 _M_ptr;         // Contained pointer.
774       __shared_count<_Lp>  _M_refcount;    // Reference counter.
775     };
776
777
778   // 20.8.13.2.7 shared_ptr comparisons
779   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
780     inline bool
781     operator==(const __shared_ptr<_Tp1, _Lp>& __a,
782                const __shared_ptr<_Tp2, _Lp>& __b)
783     { return __a.get() == __b.get(); }
784
785   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
786     inline bool
787     operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
788                const __shared_ptr<_Tp2, _Lp>& __b)
789     { return __a.get() != __b.get(); }
790
791   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
792     inline bool
793     operator<(const __shared_ptr<_Tp1, _Lp>& __a,
794               const __shared_ptr<_Tp2, _Lp>& __b)
795     { return __a.get() < __b.get(); }
796
797   template<typename _Sp>
798     struct _Sp_less : public binary_function<_Sp, _Sp, bool>
799     {
800       bool
801       operator()(const _Sp& __lhs, const _Sp& __rhs) const
802       {
803         typedef typename _Sp::element_type element_type;
804         return std::less<element_type*>()(__lhs.get(), __rhs.get());
805       }
806     };
807
808   template<typename _Tp, _Lock_policy _Lp>
809     struct less<__shared_ptr<_Tp, _Lp>>
810     : public _Sp_less<__shared_ptr<_Tp, _Lp>>
811     { };
812
813   // XXX LessThanComparable<_Tp> concept should provide >, >= and <=
814   template<typename _Tp, _Lock_policy _Lp>
815     inline bool
816     operator>(const __shared_ptr<_Tp, _Lp>& __a,
817               const __shared_ptr<_Tp, _Lp>& __b)
818     { return __a.get() > __b.get(); }
819
820   template<typename _Tp, _Lock_policy _Lp>
821     inline bool
822     operator>=(const __shared_ptr<_Tp, _Lp>& __a,
823                const __shared_ptr<_Tp, _Lp>& __b)
824     { return __a.get() >= __b.get(); }
825
826   template<typename _Tp, _Lock_policy _Lp>
827     inline bool
828     operator<=(const __shared_ptr<_Tp, _Lp>& __a,
829                const __shared_ptr<_Tp, _Lp>& __b)
830     { return __a.get() <= __b.get(); }
831
832   // 2.2.3.8 shared_ptr specialized algorithms.
833   template<typename _Tp, _Lock_policy _Lp>
834     inline void
835     swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b)
836     { __a.swap(__b); }
837
838   // 2.2.3.9 shared_ptr casts
839
840   // The seemingly equivalent code:
841   // shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
842   // will eventually result in undefined behaviour, attempting to
843   // delete the same object twice.
844   /// static_pointer_cast
845   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
846     inline __shared_ptr<_Tp, _Lp>
847     static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
848     { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
849
850   // The seemingly equivalent code:
851   // shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
852   // will eventually result in undefined behaviour, attempting to
853   // delete the same object twice.
854   /// const_pointer_cast
855   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
856     inline __shared_ptr<_Tp, _Lp>
857     const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
858     { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
859
860   // The seemingly equivalent code:
861   // shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
862   // will eventually result in undefined behaviour, attempting to
863   // delete the same object twice.
864   /// dynamic_pointer_cast
865   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
866     inline __shared_ptr<_Tp, _Lp>
867     dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
868     {
869       if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
870         return __shared_ptr<_Tp, _Lp>(__r, __p);
871       return __shared_ptr<_Tp, _Lp>();
872     }
873
874
875   template<typename _Tp, _Lock_policy _Lp>
876     class __weak_ptr
877     {
878     public:
879       typedef _Tp element_type;
880
881       __weak_ptr() : _M_ptr(0), _M_refcount() // never throws
882       { }
883
884       // Generated copy constructor, assignment, destructor are fine.
885
886       // The "obvious" converting constructor implementation:
887       //
888       //  template<typename _Tp1>
889       //    __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
890       //    : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
891       //    { }
892       //
893       // has a serious problem.
894       //
895       //  __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
896       //  conversion may require access to *__r._M_ptr (virtual inheritance).
897       //
898       // It is not possible to avoid spurious access violations since
899       // in multithreaded programs __r._M_ptr may be invalidated at any point.
900       template<typename _Tp1>
901         __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
902         : _M_refcount(__r._M_refcount) // never throws
903         {
904           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
905           _M_ptr = __r.lock().get();
906         }
907
908       template<typename _Tp1>
909         __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r)
910         : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
911         { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) }
912
913       template<typename _Tp1>
914         __weak_ptr&
915         operator=(const __weak_ptr<_Tp1, _Lp>& __r) // never throws
916         {
917           _M_ptr = __r.lock().get();
918           _M_refcount = __r._M_refcount;
919           return *this;
920         }
921
922       template<typename _Tp1>
923         __weak_ptr&
924         operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws
925         {
926           _M_ptr = __r._M_ptr;
927           _M_refcount = __r._M_refcount;
928           return *this;
929         }
930
931       __shared_ptr<_Tp, _Lp>
932       lock() const // never throws
933       {
934 #ifdef __GTHREADS
935         // Optimization: avoid throw overhead.
936         if (expired())
937           return __shared_ptr<element_type, _Lp>();
938
939         __try
940           {
941             return __shared_ptr<element_type, _Lp>(*this);
942           }
943         __catch(const bad_weak_ptr&)
944           {
945             // Q: How can we get here?
946             // A: Another thread may have invalidated r after the
947             //    use_count test above.
948             return __shared_ptr<element_type, _Lp>();
949           }
950
951 #else
952         // Optimization: avoid try/catch overhead when single threaded.
953         return expired() ? __shared_ptr<element_type, _Lp>()
954                          : __shared_ptr<element_type, _Lp>(*this);
955
956 #endif
957       } // XXX MT
958
959       long
960       use_count() const // never throws
961       { return _M_refcount._M_get_use_count(); }
962
963       bool
964       expired() const // never throws
965       { return _M_refcount._M_get_use_count() == 0; }
966
967       template<typename _Tp1>
968         bool
969         owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
970         { return _M_refcount._M_less(__rhs._M_refcount); }
971
972       template<typename _Tp1>
973         bool
974         owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
975         { return _M_refcount._M_less(__rhs._M_refcount); }
976
977       void
978       reset() // never throws
979       { __weak_ptr().swap(*this); }
980
981       void
982       swap(__weak_ptr& __s) // never throws
983       {
984         std::swap(_M_ptr, __s._M_ptr);
985         _M_refcount._M_swap(__s._M_refcount);
986       }
987
988       // Comparisons
989       template<typename _Tp1>
990         bool operator<(const __weak_ptr<_Tp1, _Lp>&) const = delete;
991
992       template<typename _Tp1>
993         bool operator<=(const __weak_ptr<_Tp1, _Lp>&) const = delete;
994
995       template<typename _Tp1>
996         bool operator>(const __weak_ptr<_Tp1, _Lp>&) const = delete;
997
998       template<typename _Tp1>
999         bool operator>=(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1000
1001     private:
1002       // Used by __enable_shared_from_this.
1003       void
1004       _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount)
1005       {
1006         _M_ptr = __ptr;
1007         _M_refcount = __refcount;
1008       }
1009
1010       template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
1011       template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
1012       friend class __enable_shared_from_this<_Tp, _Lp>;
1013       friend class enable_shared_from_this<_Tp>;
1014
1015       _Tp*               _M_ptr;         // Contained pointer.
1016       __weak_count<_Lp>  _M_refcount;    // Reference counter.
1017     };
1018
1019   // 20.8.13.3.7 weak_ptr specialized algorithms.
1020   template<typename _Tp, _Lock_policy _Lp>
1021     inline void
1022     swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b)
1023     { __a.swap(__b); }
1024
1025   template<typename _Tp, typename _Tp1>
1026     struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
1027     {
1028       bool
1029       operator()(const _Tp& __lhs, const _Tp& __rhs) const
1030       { return __lhs.owner_before(__rhs); }
1031
1032       bool
1033       operator()(const _Tp& __lhs, const _Tp1& __rhs) const
1034       { return __lhs.owner_before(__rhs); }
1035
1036       bool
1037       operator()(const _Tp1& __lhs, const _Tp& __rhs) const
1038       { return __lhs.owner_before(__rhs); }
1039     };
1040
1041   template<typename _Tp, _Lock_policy _Lp>
1042     struct owner_less<__shared_ptr<_Tp, _Lp>>
1043     : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
1044     { };
1045
1046   template<typename _Tp, _Lock_policy _Lp>
1047     struct owner_less<__weak_ptr<_Tp, _Lp>>
1048     : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
1049     { };
1050
1051
1052   template<typename _Tp, _Lock_policy _Lp>
1053     class __enable_shared_from_this
1054     {
1055     protected:
1056       __enable_shared_from_this() { }
1057
1058       __enable_shared_from_this(const __enable_shared_from_this&) { }
1059
1060       __enable_shared_from_this&
1061       operator=(const __enable_shared_from_this&)
1062       { return *this; }
1063
1064       ~__enable_shared_from_this() { }
1065
1066     public:
1067       __shared_ptr<_Tp, _Lp>
1068       shared_from_this()
1069       { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
1070
1071       __shared_ptr<const _Tp, _Lp>
1072       shared_from_this() const
1073       { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
1074
1075     private:
1076       template<typename _Tp1>
1077         void
1078         _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const
1079         { _M_weak_this._M_assign(__p, __n); }
1080
1081       template<typename _Tp1>
1082         friend void
1083         __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
1084                                          const __enable_shared_from_this* __pe,
1085                                          const _Tp1* __px)
1086         {
1087           if (__pe != 0)
1088             __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
1089         }
1090
1091       mutable __weak_ptr<_Tp, _Lp>  _M_weak_this;
1092     };
1093
1094
1095   template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
1096     inline __shared_ptr<_Tp, _Lp>
1097     __allocate_shared(_Alloc __a, _Args&&... __args)
1098     {
1099       return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(),
1100           std::forward<_Alloc>(__a), std::forward<_Args>(__args)...);
1101     }
1102
1103   template<typename _Tp, _Lock_policy _Lp, typename... _Args>
1104     inline __shared_ptr<_Tp, _Lp>
1105     __make_shared(_Args&&... __args)
1106     {
1107       typedef typename std::remove_const<_Tp>::type _Tp_nc;
1108       return __allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
1109                                          std::forward<_Args>(__args)...);
1110     }
1111
1112 _GLIBCXX_END_NAMESPACE
1113
1114 #endif // _SHARED_PTR_BASE_H