mingw/lib/gcc/mingw32/4.4.0/include/c++/bits/shared_ptr.h

   1 // shared_ptr and weak_ptr implementation -*- 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 //  shared_count.hpp
  26 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
  27
  28 //  shared_ptr.hpp
  29 //  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
  30 //  Copyright (C) 2001, 2002, 2003 Peter Dimov
  31
  32 //  weak_ptr.hpp
  33 //  Copyright (C) 2001, 2002, 2003 Peter Dimov
  34
  35 //  enable_shared_from_this.hpp
  36 //  Copyright (C) 2002 Peter Dimov
  37
  38 // Distributed under the Boost Software License, Version 1.0. (See
  39 // accompanying file LICENSE_1_0.txt or copy at
  40 // http://www.boost.org/LICENSE_1_0.txt)
  41
  42 // GCC Note:  based on version 1.32.0 of the Boost library.
  43
  44 /** @file bits/shared_ptr.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_H
  50 #define _SHARED_PTR_H 1
  51
  52 #ifndef __GXX_EXPERIMENTAL_CXX0X__
  53 # include <c++0x_warning.h>
  54 #endif
  55
  56 #if defined(_GLIBCXX_INCLUDE_AS_TR1)
  57 #  error C++0x header cannot be included from TR1 header
  58 #endif
  59
  60 _GLIBCXX_BEGIN_NAMESPACE(std)
  61
  62   /**
  63    * @addtogroup pointer_abstractions
  64    * @{
  65    */
  66
  67   // counted ptr with no deleter or allocator support
  68   template<typename _Ptr, _Lock_policy _Lp>
  69     class _Sp_counted_ptr
  70     : public _Sp_counted_base<_Lp>
  71     {
  72     public:
  73       _Sp_counted_ptr(_Ptr __p)
  74       : _M_ptr(__p) { }
  75
  76       virtual void
  77       _M_dispose() // nothrow
  78       { delete _M_ptr; }
  79
  80       virtual void
  81       _M_destroy() // nothrow
  82       { delete this; }
  83
  84       virtual void*
  85       _M_get_deleter(const std::type_info& __ti)
  86       { return 0; }
  87
  88       _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
  89       _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
  90
  91     protected:
  92       _Ptr             _M_ptr;  // copy constructor must not throw
  93     };
  94
  95   // support for custom deleter and/or allocator
  96   template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
  97     class _Sp_counted_deleter
  98     : public _Sp_counted_ptr<_Ptr, _Lp>
  99     {
 100       typedef typename _Alloc::template
 101           rebind<_Sp_counted_deleter>::other _My_alloc_type;
 102
 103       // Helper class that stores the Deleter and also acts as an allocator.
 104       // Used to dispose of the owned pointer and the internal refcount
 105       // Requires that copies of _Alloc can free each other's memory.
 106       struct _My_Deleter
 107       : public _My_alloc_type    // copy constructor must not throw
 108       {
 109         _Deleter _M_del;         // copy constructor must not throw
 110         _My_Deleter(_Deleter __d, const _Alloc& __a)
 111           : _My_alloc_type(__a), _M_del(__d) { }
 112       };
 113
 114     protected:
 115       typedef _Sp_counted_ptr<_Ptr, _Lp> _Base_type;
 116
 117     public:
 118       /**
 119        *  @brief
 120        *  @pre     __d(__p) must not throw.
 121        */
 122       _Sp_counted_deleter(_Ptr __p, _Deleter __d)
 123       : _Base_type(__p), _M_del(__d, _Alloc()) { }
 124
 125       /**
 126        *  @brief
 127        *  @pre     __d(__p) must not throw.
 128        */
 129       _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a)
 130       : _Base_type(__p), _M_del(__d, __a) { }
 131
 132       virtual void
 133       _M_dispose() // nothrow
 134       { _M_del._M_del(_Base_type::_M_ptr); }
 135
 136       virtual void
 137       _M_destroy() // nothrow
 138       {
 139         _My_alloc_type __a(_M_del);
 140         this->~_Sp_counted_deleter();
 141         __a.deallocate(this, 1);
 142       }
 143
 144       virtual void*
 145       _M_get_deleter(const std::type_info& __ti)
 146       { return __ti == typeid(_Deleter) ? &_M_del._M_del : 0; }
 147
 148     protected:
 149       _My_Deleter      _M_del;  // copy constructor must not throw
 150     };
 151
 152   // helpers for make_shared / allocate_shared
 153
 154   template<typename _Tp>
 155     struct _Sp_destroy_inplace
 156     {
 157       void operator()(_Tp* __p) const { if (__p) __p->~_Tp(); }
 158     };
 159
 160   struct _Sp_make_shared_tag { };
 161
 162   template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
 163     class _Sp_counted_ptr_inplace
 164     : public _Sp_counted_deleter<_Tp*, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp>
 165     {
 166       typedef _Sp_counted_deleter<_Tp*, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp>
 167         _Base_type;
 168
 169     public:
 170       _Sp_counted_ptr_inplace(_Alloc __a)
 171       : _Base_type(static_cast<_Tp*>(0), _Sp_destroy_inplace<_Tp>(), __a)
 172       , _M_storage()
 173       {
 174         void* __p = &_M_storage;
 175         ::new (__p) _Tp();  // might throw
 176         _Base_type::_Base_type::_M_ptr = static_cast<_Tp*>(__p);
 177       }
 178
 179       template<typename... _Args>
 180         _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
 181         : _Base_type(static_cast<_Tp*>(0), _Sp_destroy_inplace<_Tp>(), __a)
 182         , _M_storage()
 183         {
 184           void* __p = &_M_storage;
 185           ::new (__p) _Tp(std::forward<_Args>(__args)...);  // might throw
 186           _Base_type::_Base_type::_M_ptr = static_cast<_Tp*>(__p);
 187         }
 188
 189       // override because the allocator needs to know the dynamic type
 190       virtual void
 191       _M_destroy() // nothrow
 192       {
 193         typedef typename _Alloc::template
 194             rebind<_Sp_counted_ptr_inplace>::other _My_alloc_type;
 195         _My_alloc_type __a(_Base_type::_M_del);
 196         this->~_Sp_counted_ptr_inplace();
 197         __a.deallocate(this, 1);
 198       }
 199
 200       // sneaky trick so __shared_ptr can get the managed pointer
 201       virtual void*
 202       _M_get_deleter(const std::type_info& __ti)
 203       {
 204         return __ti == typeid(_Sp_make_shared_tag)
 205                ? static_cast<void*>(&_M_storage)
 206                : _Base_type::_M_get_deleter(__ti);
 207       }
 208
 209     private:
 210       typename aligned_storage<sizeof(_Tp), alignment_of<_Tp>::value>::type
 211         _M_storage;
 212     };
 213
 214   template<_Lock_policy _Lp = __default_lock_policy>
 215     class __weak_count;
 216
 217   template<_Lock_policy _Lp = __default_lock_policy>
 218     class __shared_count
 219     {
 220     public:
 221       __shared_count()
 222       : _M_pi(0) // nothrow
 223       { }
 224
 225       template<typename _Ptr>
 226         __shared_count(_Ptr __p) : _M_pi(0)
 227         {
 228           __try
 229             {
 230               _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
 231             }
 232           __catch(...)
 233             {
 234               delete __p;
 235               __throw_exception_again;
 236             }
 237         }
 238
 239       template<typename _Ptr, typename _Deleter>
 240         __shared_count(_Ptr __p, _Deleter __d) : _M_pi(0)
 241         {
 242           // allocator's value_type doesn't matter, will rebind it anyway
 243           typedef std::allocator<int> _Alloc;
 244           typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
 245           typedef std::allocator<_Sp_cd_type> _Alloc2;
 246           _Alloc2 __a2;
 247           __try
 248             {
 249               _M_pi = __a2.allocate(1);
 250               ::new(static_cast<void*>(_M_pi)) _Sp_cd_type(__p, __d);
 251             }
 252           __catch(...)
 253             {
 254               __d(__p); // Call _Deleter on __p.
 255               if (_M_pi)
 256                 __a2.deallocate(static_cast<_Sp_cd_type*>(_M_pi), 1);
 257               __throw_exception_again;
 258             }
 259         }
 260
 261       template<typename _Ptr, typename _Deleter, typename _Alloc>
 262         __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
 263         {
 264           typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
 265           typedef typename _Alloc::template rebind<_Sp_cd_type>::other _Alloc2;
 266           _Alloc2 __a2(__a);
 267           __try
 268             {
 269               _M_pi = __a2.allocate(1);
 270               ::new(static_cast<void*>(_M_pi)) _Sp_cd_type(__p, __d, __a);
 271             }
 272           __catch(...)
 273             {
 274               __d(__p); // Call _Deleter on __p.
 275               if (_M_pi)
 276                 __a2.deallocate(static_cast<_Sp_cd_type*>(_M_pi), 1);
 277               __throw_exception_again;
 278             }
 279         }
 280
 281       template<typename _Tp, typename _Alloc, typename... _Args>
 282         __shared_count(_Sp_make_shared_tag, _Tp*, _Alloc __a, _Args&&... __args)
 283         : _M_pi(0)
 284         {
 285           typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
 286           typedef typename _Alloc::template rebind<_Sp_cp_type>::other _Alloc2;
 287           _Alloc2 __a2(__a);
 288           __try
 289             {
 290               _M_pi = __a2.allocate(1);
 291               ::new(static_cast<void*>(_M_pi)) _Sp_cp_type(__a,
 292                     std::forward<_Args>(__args)...);
 293             }
 294           __catch(...)
 295             {
 296               if (_M_pi)
 297                 __a2.deallocate(static_cast<_Sp_cp_type*>(_M_pi), 1);
 298               __throw_exception_again;
 299             }
 300         }
 301
 302 #if _GLIBCXX_DEPRECATED
 303       // Special case for auto_ptr<_Tp> to provide the strong guarantee.
 304       template<typename _Tp>
 305         explicit
 306         __shared_count(std::auto_ptr<_Tp>&& __r)
 307         : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
 308         { __r.release(); }
 309 #endif
 310
 311       // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
 312       template<typename _Tp, typename _Del>
 313         explicit
 314         __shared_count(std::unique_ptr<_Tp, _Del>&& __r)
 315         : _M_pi(_S_create_from_up(std::move(__r)))
 316         { __r.release(); }
 317
 318       // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
 319       explicit
 320       __shared_count(const __weak_count<_Lp>& __r);
 321
 322       ~__shared_count() // nothrow
 323       {
 324         if (_M_pi != 0)
 325           _M_pi->_M_release();
 326       }
 327
 328       __shared_count(const __shared_count& __r)
 329       : _M_pi(__r._M_pi) // nothrow
 330       {
 331         if (_M_pi != 0)
 332           _M_pi->_M_add_ref_copy();
 333       }
 334
 335       __shared_count&
 336       operator=(const __shared_count& __r) // nothrow
 337       {
 338         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 339         if (__tmp != _M_pi)
 340           {
 341             if (__tmp != 0)
 342               __tmp->_M_add_ref_copy();
 343             if (_M_pi != 0)
 344               _M_pi->_M_release();
 345             _M_pi = __tmp;
 346           }
 347         return *this;
 348       }
 349
 350       void
 351       _M_swap(__shared_count& __r) // nothrow
 352       {
 353         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 354         __r._M_pi = _M_pi;
 355         _M_pi = __tmp;
 356       }
 357
 358       long
 359       _M_get_use_count() const // nothrow
 360       { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
 361
 362       bool
 363       _M_unique() const // nothrow
 364       { return this->_M_get_use_count() == 1; }
 365
 366       void*
 367       _M_get_deleter(const std::type_info& __ti) const
 368       { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; }
 369
 370       bool
 371       _M_less(const __shared_count& __rhs) const
 372       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
 373
 374       bool
 375       _M_less(const __weak_count<_Lp>& __rhs) const
 376       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
 377
 378       // friend function injected into enclosing namespace and found by ADL
 379       friend inline bool
 380       operator==(const __shared_count& __a, const __shared_count& __b)
 381       { return __a._M_pi == __b._M_pi; }
 382
 383     private:
 384       friend class __weak_count<_Lp>;
 385
 386       template<typename _Tp, typename _Del>
 387         static _Sp_counted_base<_Lp>*
 388         _S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r,
 389           typename std::enable_if<!std::is_reference<_Del>::value>::type* = 0)
 390         {
 391           return new _Sp_counted_deleter<_Tp*, _Del, std::allocator<_Tp>,
 392             _Lp>(__r.get(), __r.get_deleter());
 393         }
 394
 395       template<typename _Tp, typename _Del>
 396         static _Sp_counted_base<_Lp>*
 397         _S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r,
 398           typename std::enable_if<std::is_reference<_Del>::value>::type* = 0)
 399         {
 400           typedef typename std::remove_reference<_Del>::type _Del1;
 401           typedef std::reference_wrapper<_Del1> _Del2;
 402           return new _Sp_counted_deleter<_Tp*, _Del2, std::allocator<_Tp>,
 403             _Lp>(__r.get(), std::ref(__r.get_deleter()));
 404         }
 405
 406       _Sp_counted_base<_Lp>*  _M_pi;
 407     };
 408
 409
 410   template<_Lock_policy _Lp>
 411     class __weak_count
 412     {
 413     public:
 414       __weak_count()
 415       : _M_pi(0) // nothrow
 416       { }
 417
 418       __weak_count(const __shared_count<_Lp>& __r)
 419       : _M_pi(__r._M_pi) // nothrow
 420       {
 421         if (_M_pi != 0)
 422           _M_pi->_M_weak_add_ref();
 423       }
 424
 425       __weak_count(const __weak_count<_Lp>& __r)
 426       : _M_pi(__r._M_pi) // nothrow
 427       {
 428         if (_M_pi != 0)
 429           _M_pi->_M_weak_add_ref();
 430       }
 431
 432       ~__weak_count() // nothrow
 433       {
 434         if (_M_pi != 0)
 435           _M_pi->_M_weak_release();
 436       }
 437
 438       __weak_count<_Lp>&
 439       operator=(const __shared_count<_Lp>& __r) // nothrow
 440       {
 441         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 442         if (__tmp != 0)
 443           __tmp->_M_weak_add_ref();
 444         if (_M_pi != 0)
 445           _M_pi->_M_weak_release();
 446         _M_pi = __tmp;
 447         return *this;
 448       }
 449
 450       __weak_count<_Lp>&
 451       operator=(const __weak_count<_Lp>& __r) // nothrow
 452       {
 453         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 454         if (__tmp != 0)
 455           __tmp->_M_weak_add_ref();
 456         if (_M_pi != 0)
 457           _M_pi->_M_weak_release();
 458         _M_pi = __tmp;
 459         return *this;
 460       }
 461
 462       void
 463       _M_swap(__weak_count<_Lp>& __r) // nothrow
 464       {
 465         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
 466         __r._M_pi = _M_pi;
 467         _M_pi = __tmp;
 468       }
 469
 470       long
 471       _M_get_use_count() const // nothrow
 472       { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
 473
 474       bool
 475       _M_less(const __weak_count& __rhs) const
 476       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
 477
 478       bool
 479       _M_less(const __shared_count<_Lp>& __rhs) const
 480       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
 481
 482       // friend function injected into enclosing namespace and found by ADL
 483       friend inline bool
 484       operator==(const __weak_count& __a, const __weak_count& __b)
 485       { return __a._M_pi == __b._M_pi; }
 486
 487     private:
 488       friend class __shared_count<_Lp>;
 489
 490       _Sp_counted_base<_Lp>*  _M_pi;
 491     };
 492
 493   // now that __weak_count is defined we can define this constructor:
 494   template<_Lock_policy _Lp>
 495     inline
 496     __shared_count<_Lp>::
 497     __shared_count(const __weak_count<_Lp>& __r)
 498     : _M_pi(__r._M_pi)
 499     {
 500       if (_M_pi != 0)
 501         _M_pi->_M_add_ref_lock();
 502       else
 503         __throw_bad_weak_ptr();
 504     }
 505
 506   // Forward declarations.
 507   template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
 508     class __shared_ptr;
 509
 510   template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
 511     class __weak_ptr;
 512
 513   template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
 514     class __enable_shared_from_this;
 515
 516   template<typename _Tp>
 517     class shared_ptr;
 518
 519   template<typename _Tp>
 520     class weak_ptr;
 521
 522   template<typename _Tp>
 523     class enable_shared_from_this;
 524
 525   // Support for enable_shared_from_this.
 526
 527   // Friend of __enable_shared_from_this.
 528   template<_Lock_policy _Lp, typename _Tp1, typename _Tp2>
 529     void
 530     __enable_shared_from_this_helper(const __shared_count<_Lp>&,
 531                                      const __enable_shared_from_this<_Tp1,
 532                                      _Lp>*, const _Tp2*);
 533
 534   // Friend of enable_shared_from_this.
 535   template<typename _Tp1, typename _Tp2>
 536     void
 537     __enable_shared_from_this_helper(const __shared_count<>&,
 538                                      const enable_shared_from_this<_Tp1>*,
 539                                      const _Tp2*);
 540
 541   template<_Lock_policy _Lp>
 542     inline void
 543     __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...)
 544     { }
 545
 546
 547   template<typename _Tp, _Lock_policy _Lp>
 548     class __shared_ptr
 549     {
 550     public:
 551       typedef _Tp   element_type;
 552
 553       /** @brief  Construct an empty %__shared_ptr.
 554        *  @post   use_count()==0 && get()==0
 555        */
 556       __shared_ptr()
 557       : _M_ptr(0), _M_refcount() // never throws
 558       { }
 559
 560       /** @brief  Construct a %__shared_ptr that owns the pointer @a __p.
 561        *  @param  __p  A pointer that is convertible to element_type*.
 562        *  @post   use_count() == 1 && get() == __p
 563        *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
 564        */
 565       template<typename _Tp1>
 566         explicit
 567         __shared_ptr(_Tp1* __p)
 568         : _M_ptr(__p), _M_refcount(__p)
 569         {
 570           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
 571           // __glibcxx_function_requires(_CompleteConcept<_Tp1*>)
 572           __enable_shared_from_this_helper(_M_refcount, __p, __p);
 573         }
 574
 575       //
 576       // Requirements: _Deleter's copy constructor and destructor must
 577       // not throw
 578       //
 579       // __shared_ptr will release __p by calling __d(__p)
 580       //
 581       /** @brief  Construct a %__shared_ptr that owns the pointer @a __p
 582        *          and the deleter @a __d.
 583        *  @param  __p  A pointer.
 584        *  @param  __d  A deleter.
 585        *  @post   use_count() == 1 && get() == __p
 586        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
 587        */
 588       template<typename _Tp1, typename _Deleter>
 589         __shared_ptr(_Tp1* __p, _Deleter __d)
 590         : _M_ptr(__p), _M_refcount(__p, __d)
 591         {
 592           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
 593           // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
 594           __enable_shared_from_this_helper(_M_refcount, __p, __p);
 595         }
 596
 597       //
 598       // Requirements: _Deleter's copy constructor and destructor must
 599       // not throw _Alloc's copy constructor and destructor must not
 600       // throw.
 601       //
 602       // __shared_ptr will release __p by calling __d(__p)
 603       //
 604       /** @brief  Construct a %__shared_ptr that owns the pointer @a __p
 605        *          and the deleter @a __d.
 606        *  @param  __p  A pointer.
 607        *  @param  __d  A deleter.
 608        *  @param  __a  An allocator.
 609        *  @post   use_count() == 1 && get() == __p
 610        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
 611        */
 612       template<typename _Tp1, typename _Deleter, typename _Alloc>
 613         __shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a)
 614         : _M_ptr(__p), _M_refcount(__p, __d, __a)
 615         {
 616           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
 617           // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
 618           __enable_shared_from_this_helper(_M_refcount, __p, __p);
 619         }
 620
 621       /** @brief  Constructs a %__shared_ptr instance that stores @a __p
 622        *          and shares ownership with @a __r.
 623        *  @param  __r  A %__shared_ptr.
 624        *  @param  __p  A pointer that will remain valid while @a *__r is valid.
 625        *  @post   get() == __p && use_count() == __r.use_count()
 626        *
 627        *  This can be used to construct a @c shared_ptr to a sub-object
 628        *  of an object managed by an existing @c shared_ptr.
 629        *
 630        * @code
 631        * shared_ptr< pair<int,int> > pii(new pair<int,int>());
 632        * shared_ptr<int> pi(pii, &pii->first);
 633        * assert(pii.use_count() == 2);
 634        * @endcode
 635        */
 636       template<typename _Tp1>
 637         __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p)
 638         : _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
 639         { }
 640
 641       //  generated copy constructor, assignment, destructor are fine.
 642
 643       /** @brief  If @a __r is empty, constructs an empty %__shared_ptr;
 644        *          otherwise construct a %__shared_ptr that shares ownership
 645        *          with @a __r.
 646        *  @param  __r  A %__shared_ptr.
 647        *  @post   get() == __r.get() && use_count() == __r.use_count()
 648        */
 649       template<typename _Tp1>
 650         __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r)
 651         : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
 652         { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) }
 653
 654       /** @brief  Move-constructs a %__shared_ptr instance from @a __r.
 655        *  @param  __r  A %__shared_ptr rvalue.
 656        *  @post   *this contains the old value of @a __r, @a __r is empty.
 657        */
 658       __shared_ptr(__shared_ptr&& __r)
 659       : _M_ptr(__r._M_ptr), _M_refcount() // never throws
 660       {
 661         _M_refcount._M_swap(__r._M_refcount);
 662         __r._M_ptr = 0;
 663       }
 664
 665       /** @brief  Move-constructs a %__shared_ptr instance from @a __r.
 666        *  @param  __r  A %__shared_ptr rvalue.
 667        *  @post   *this contains the old value of @a __r, @a __r is empty.
 668        */
 669       template<typename _Tp1>
 670         __shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r)
 671         : _M_ptr(__r._M_ptr), _M_refcount() // never throws
 672         {
 673           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
 674           _M_refcount._M_swap(__r._M_refcount);
 675           __r._M_ptr = 0;
 676         }
 677
 678       /** @brief  Constructs a %__shared_ptr that shares ownership with @a __r
 679        *          and stores a copy of the pointer stored in @a __r.
 680        *  @param  __r  A weak_ptr.
 681        *  @post   use_count() == __r.use_count()
 682        *  @throw  bad_weak_ptr when __r.expired(),
 683        *          in which case the constructor has no effect.
 684        */
 685       template<typename _Tp1>
 686         explicit
 687         __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
 688         : _M_refcount(__r._M_refcount) // may throw
 689         {
 690           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
 691           // It is now safe to copy __r._M_ptr, as _M_refcount(__r._M_refcount)
 692           // did not throw.
 693           _M_ptr = __r._M_ptr;
 694         }
 695
 696       template<typename _Tp1, typename _Del>
 697         explicit
 698         __shared_ptr(const std::unique_ptr<_Tp1, _Del>&) = delete;
 699
 700       /**
 701        * If an exception is thrown this constructor has no effect.
 702        */
 703       template<typename _Tp1, typename _Del>
 704         explicit
 705         __shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
 706         : _M_ptr(__r.get()), _M_refcount()
 707         {
 708           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
 709           _Tp1* __tmp = __r.get();
 710           _M_refcount = __shared_count<_Lp>(std::move(__r));
 711           __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
 712         }
 713
 714 #if _GLIBCXX_DEPRECATED
 715       /**
 716        * @post use_count() == 1 and __r.get() == 0
 717        */
 718       template<typename _Tp1>
 719         explicit
 720         __shared_ptr(std::auto_ptr<_Tp1>&& __r)
 721         : _M_ptr(__r.get()), _M_refcount()
 722         {
 723           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
 724           // TODO requires _Tp1 is complete, delete __r.release() well-formed
 725           _Tp1* __tmp = __r.get();
 726           _M_refcount = __shared_count<_Lp>(std::move(__r));
 727           __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
 728         }
 729 #endif
 730
 731       template<typename _Tp1>
 732         __shared_ptr&
 733         operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws
 734         {
 735           _M_ptr = __r._M_ptr;
 736           _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
 737           return *this;
 738         }
 739
 740 #if _GLIBCXX_DEPRECATED
 741       template<typename _Tp1>
 742         __shared_ptr&
 743         operator=(std::auto_ptr<_Tp1>&& __r)
 744         {
 745           __shared_ptr(std::move(__r)).swap(*this);
 746           return *this;
 747         }
 748 #endif
 749
 750       __shared_ptr&
 751       operator=(__shared_ptr&& __r)
 752       {
 753         __shared_ptr(std::move(__r)).swap(*this);
 754         return *this;
 755       }
 756
 757       template<class _Tp1>
 758         __shared_ptr&
 759         operator=(__shared_ptr<_Tp1, _Lp>&& __r)
 760         {
 761           __shared_ptr(std::move(__r)).swap(*this);
 762           return *this;
 763         }
 764
 765       template<typename _Tp1, typename _Del>
 766         __shared_ptr&
 767         operator=(const std::unique_ptr<_Tp1, _Del>& __r) = delete;
 768
 769       template<typename _Tp1, typename _Del>
 770         __shared_ptr&
 771         operator=(std::unique_ptr<_Tp1, _Del>&& __r)
 772         {
 773           __shared_ptr(std::move(__r)).swap(*this);
 774           return *this;
 775         }
 776
 777       void
 778       reset() // never throws
 779       { __shared_ptr().swap(*this); }
 780
 781       template<typename _Tp1>
 782         void
 783         reset(_Tp1* __p) // _Tp1 must be complete.
 784         {
 785           // Catch self-reset errors.
 786           _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr);
 787           __shared_ptr(__p).swap(*this);
 788         }
 789
 790       template<typename _Tp1, typename _Deleter>
 791         void
 792         reset(_Tp1* __p, _Deleter __d)
 793         { __shared_ptr(__p, __d).swap(*this); }
 794
 795       template<typename _Tp1, typename _Deleter, typename _Alloc>
 796         void
 797         reset(_Tp1* __p, _Deleter __d, const _Alloc& __a)
 798         { __shared_ptr(__p, __d, __a).swap(*this); }
 799
 800       // Allow class instantiation when _Tp is [cv-qual] void.
 801       typename std::add_lvalue_reference<_Tp>::type
 802       operator*() const // never throws
 803       {
 804         _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
 805         return *_M_ptr;
 806       }
 807
 808       _Tp*
 809       operator->() const // never throws
 810       {
 811         _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
 812         return _M_ptr;
 813       }
 814
 815       _Tp*
 816       get() const // never throws
 817       { return _M_ptr; }
 818
 819       // Implicit conversion to "bool"
 820     private:
 821       typedef _Tp* __shared_ptr::*__unspecified_bool_type;
 822
 823     public:
 824       operator __unspecified_bool_type() const // never throws
 825       { return _M_ptr == 0 ? 0 : &__shared_ptr::_M_ptr; }
 826
 827       bool
 828       unique() const // never throws
 829       { return _M_refcount._M_unique(); }
 830
 831       long
 832       use_count() const // never throws
 833       { return _M_refcount._M_get_use_count(); }
 834
 835       void
 836       swap(__shared_ptr<_Tp, _Lp>&& __other) // never throws
 837       {
 838         std::swap(_M_ptr, __other._M_ptr);
 839         _M_refcount._M_swap(__other._M_refcount);
 840       }
 841
 842       template<typename _Tp1>
 843         bool
 844         owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
 845         { return _M_refcount._M_less(__rhs._M_refcount); }
 846
 847       template<typename _Tp1>
 848         bool
 849         owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
 850         { return _M_refcount._M_less(__rhs._M_refcount); }
 851
 852     protected:
 853       // This constructor is non-standard, it is used by allocate_shared.
 854       template<typename _Alloc, typename... _Args>
 855         __shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args)
 856         : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
 857                                 std::forward<_Args>(__args)...)
 858         {
 859           // _M_ptr needs to point to the newly constructed object.
 860           // This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
 861           void* __p = _M_refcount._M_get_deleter(typeid(__tag));
 862           _M_ptr = static_cast<_Tp*>(__p);
 863           __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
 864         }
 865
 866       template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
 867                typename... _Args>
 868         friend __shared_ptr<_Tp1, _Lp1>
 869         __allocate_shared(_Alloc __a, _Args&&... __args);
 870
 871     private:
 872       void*
 873       _M_get_deleter(const std::type_info& __ti) const
 874       { return _M_refcount._M_get_deleter(__ti); }
 875
 876       template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
 877       template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
 878
 879       template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
 880         friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&);
 881
 882       _Tp*                 _M_ptr;         // Contained pointer.
 883       __shared_count<_Lp>  _M_refcount;    // Reference counter.
 884     };
 885
 886   // 20.8.13.2.7 shared_ptr comparisons
 887   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
 888     inline bool
 889     operator==(const __shared_ptr<_Tp1, _Lp>& __a,
 890         const __shared_ptr<_Tp2, _Lp>& __b)
 891     { return __a.get() == __b.get(); }
 892
 893   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
 894     inline bool
 895     operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
 896         const __shared_ptr<_Tp2, _Lp>& __b)
 897     { return __a.get() != __b.get(); }
 898
 899   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
 900     inline bool
 901     operator<(const __shared_ptr<_Tp1, _Lp>& __a,
 902         const __shared_ptr<_Tp2, _Lp>& __b)
 903     { return __a.get() < __b.get(); }
 904
 905   template<typename _Sp>
 906     struct _Sp_less : public binary_function<_Sp, _Sp, bool>
 907     {
 908       bool
 909       operator()(const _Sp& __lhs, const _Sp& __rhs) const
 910       {
 911         return std::less<typename _Sp::element_type*>()(__lhs.get(),
 912             __rhs.get());
 913       }
 914     };
 915
 916   template<typename _Tp, _Lock_policy _Lp>
 917     struct less<__shared_ptr<_Tp, _Lp>>
 918     : public _Sp_less<__shared_ptr<_Tp, _Lp>>
 919     { };
 920
 921   // XXX LessThanComparable<_Tp> concept should provide >, >= and <=
 922   template<typename _Tp, _Lock_policy _Lp>
 923     inline bool
 924     operator>(const __shared_ptr<_Tp, _Lp>& __a,
 925         const __shared_ptr<_Tp, _Lp>& __b)
 926     { return __a.get() > __b.get(); }
 927
 928   template<typename _Tp, _Lock_policy _Lp>
 929     inline bool
 930     operator>=(const __shared_ptr<_Tp, _Lp>& __a,
 931         const __shared_ptr<_Tp, _Lp>& __b)
 932     { return __a.get() >= __b.get(); }
 933
 934   template<typename _Tp, _Lock_policy _Lp>
 935     inline bool
 936     operator<=(const __shared_ptr<_Tp, _Lp>& __a,
 937         const __shared_ptr<_Tp, _Lp>& __b)
 938     { return __a.get() <= __b.get(); }
 939
 940   // 2.2.3.8 shared_ptr specialized algorithms.
 941   template<typename _Tp, _Lock_policy _Lp>
 942     inline void
 943     swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b)
 944     { __a.swap(__b); }
 945
 946   template<typename _Tp, _Lock_policy _Lp>
 947     inline void
 948     swap(__shared_ptr<_Tp, _Lp>&& __a, __shared_ptr<_Tp, _Lp>& __b)
 949     { __a.swap(__b); }
 950
 951   template<typename _Tp, _Lock_policy _Lp>
 952     inline void
 953     swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>&& __b)
 954     { __a.swap(__b); }
 955
 956   // 2.2.3.9 shared_ptr casts
 957   /** @warning The seemingly equivalent
 958    *           <code>shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))</code>
 959    *           will eventually result in undefined behaviour,
 960    *           attempting to delete the same object twice.
 961    */
 962   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
 963     inline __shared_ptr<_Tp, _Lp>
 964     static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
 965     { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
 966
 967   /** @warning The seemingly equivalent
 968    *           <code>shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))</code>
 969    *           will eventually result in undefined behaviour,
 970    *           attempting to delete the same object twice.
 971    */
 972   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
 973     inline __shared_ptr<_Tp, _Lp>
 974     const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
 975     { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
 976
 977   /** @warning The seemingly equivalent
 978    *           <code>shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))</code>
 979    *           will eventually result in undefined behaviour,
 980    *           attempting to delete the same object twice.
 981    */
 982   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
 983     inline __shared_ptr<_Tp, _Lp>
 984     dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
 985     {
 986       if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
 987         return __shared_ptr<_Tp, _Lp>(__r, __p);
 988       return __shared_ptr<_Tp, _Lp>();
 989     }
 990
 991   // 2.2.3.7 shared_ptr I/O
 992   template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
 993     std::basic_ostream<_Ch, _Tr>&
 994     operator<<(std::basic_ostream<_Ch, _Tr>& __os,
 995                const __shared_ptr<_Tp, _Lp>& __p)
 996     {
 997       __os << __p.get();
 998       return __os;
 999     }
1000
1001   // 2.2.3.10 shared_ptr get_deleter (experimental)
1002   template<typename _Del, typename _Tp, _Lock_policy _Lp>
1003     inline _Del*
1004     get_deleter(const __shared_ptr<_Tp, _Lp>& __p)
1005     { return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); }
1006
1007
1008   template<typename _Tp, _Lock_policy _Lp>
1009     class __weak_ptr
1010     {
1011     public:
1012       typedef _Tp element_type;
1013
1014       __weak_ptr()
1015       : _M_ptr(0), _M_refcount() // never throws
1016       { }
1017
1018       // Generated copy constructor, assignment, destructor are fine.
1019
1020       // The "obvious" converting constructor implementation:
1021       //
1022       //  template<typename _Tp1>
1023       //    __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
1024       //    : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
1025       //    { }
1026       //
1027       // has a serious problem.
1028       //
1029       //  __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
1030       //  conversion may require access to *__r._M_ptr (virtual inheritance).
1031       //
1032       // It is not possible to avoid spurious access violations since
1033       // in multithreaded programs __r._M_ptr may be invalidated at any point.
1034       template<typename _Tp1>
1035         __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
1036         : _M_refcount(__r._M_refcount) // never throws
1037         {
1038           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
1039           _M_ptr = __r.lock().get();
1040         }
1041
1042       template<typename _Tp1>
1043         __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r)
1044         : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
1045         { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) }
1046
1047       template<typename _Tp1>
1048         __weak_ptr&
1049         operator=(const __weak_ptr<_Tp1, _Lp>& __r) // never throws
1050         {
1051           _M_ptr = __r.lock().get();
1052           _M_refcount = __r._M_refcount;
1053           return *this;
1054         }
1055
1056       template<typename _Tp1>
1057         __weak_ptr&
1058         operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws
1059         {
1060           _M_ptr = __r._M_ptr;
1061           _M_refcount = __r._M_refcount;
1062           return *this;
1063         }
1064
1065       __shared_ptr<_Tp, _Lp>
1066       lock() const // never throws
1067       {
1068 #ifdef __GTHREADS
1069         // Optimization: avoid throw overhead.
1070         if (expired())
1071           return __shared_ptr<element_type, _Lp>();
1072
1073         __try
1074           {
1075             return __shared_ptr<element_type, _Lp>(*this);
1076           }
1077         __catch(const bad_weak_ptr&)
1078           {
1079             // Q: How can we get here?
1080             // A: Another thread may have invalidated r after the
1081             //    use_count test above.
1082             return __shared_ptr<element_type, _Lp>();
1083           }
1084
1085 #else
1086         // Optimization: avoid try/catch overhead when single threaded.
1087         return expired() ? __shared_ptr<element_type, _Lp>()
1088                          : __shared_ptr<element_type, _Lp>(*this);
1089
1090 #endif
1091       } // XXX MT
1092
1093       long
1094       use_count() const // never throws
1095       { return _M_refcount._M_get_use_count(); }
1096
1097       bool
1098       expired() const // never throws
1099       { return _M_refcount._M_get_use_count() == 0; }
1100
1101       template<typename _Tp1>
1102         bool
1103         owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
1104         { return _M_refcount._M_less(__rhs._M_refcount); }
1105
1106       template<typename _Tp1>
1107         bool
1108         owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
1109         { return _M_refcount._M_less(__rhs._M_refcount); }
1110
1111       void
1112       reset() // never throws
1113       { __weak_ptr().swap(*this); }
1114
1115       void
1116       swap(__weak_ptr& __s) // never throws
1117       {
1118         std::swap(_M_ptr, __s._M_ptr);
1119         _M_refcount._M_swap(__s._M_refcount);
1120       }
1121
1122       // comparisons
1123       template<typename _Tp1>
1124         bool operator<(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1125       template<typename _Tp1>
1126         bool operator<=(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1127       template<typename _Tp1>
1128         bool operator>(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1129       template<typename _Tp1>
1130         bool operator>=(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1131
1132     private:
1133       // Used by __enable_shared_from_this.
1134       void
1135       _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount)
1136       {
1137         _M_ptr = __ptr;
1138         _M_refcount = __refcount;
1139       }
1140
1141       template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
1142       template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
1143       friend class __enable_shared_from_this<_Tp, _Lp>;
1144       friend class enable_shared_from_this<_Tp>;
1145
1146       _Tp*               _M_ptr;         // Contained pointer.
1147       __weak_count<_Lp>  _M_refcount;    // Reference counter.
1148     };
1149
1150   // 20.8.13.3.7 weak_ptr specialized algorithms.
1151   template<typename _Tp, _Lock_policy _Lp>
1152     inline void
1153     swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b)
1154     { __a.swap(__b); }
1155
1156   /// owner_less
1157   template<typename _Tp> struct owner_less;
1158
1159   template<typename _Tp, typename _Tp1>
1160     struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
1161     {
1162       bool
1163       operator()(const _Tp& __lhs, const _Tp& __rhs) const
1164       { return __lhs.owner_before(__rhs); }
1165       bool
1166       operator()(const _Tp& __lhs, const _Tp1& __rhs) const
1167       { return __lhs.owner_before(__rhs); }
1168       bool
1169       operator()(const _Tp1& __lhs, const _Tp& __rhs) const
1170       { return __lhs.owner_before(__rhs); }
1171     };
1172
1173   template<typename _Tp, _Lock_policy _Lp>
1174     struct owner_less<__shared_ptr<_Tp, _Lp>>
1175     : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
1176     { };
1177
1178   template<typename _Tp, _Lock_policy _Lp>
1179     struct owner_less<__weak_ptr<_Tp, _Lp>>
1180     : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
1181     {
1182     };
1183
1184
1185   template<typename _Tp, _Lock_policy _Lp>
1186     class __enable_shared_from_this
1187     {
1188     protected:
1189       __enable_shared_from_this() { }
1190
1191       __enable_shared_from_this(const __enable_shared_from_this&) { }
1192
1193       __enable_shared_from_this&
1194       operator=(const __enable_shared_from_this&)
1195       { return *this; }
1196
1197       ~__enable_shared_from_this() { }
1198
1199     public:
1200       __shared_ptr<_Tp, _Lp>
1201       shared_from_this()
1202       { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
1203
1204       __shared_ptr<const _Tp, _Lp>
1205       shared_from_this() const
1206       { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
1207
1208     private:
1209       template<typename _Tp1>
1210         void
1211         _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const
1212         { _M_weak_this._M_assign(__p, __n); }
1213
1214       template<typename _Tp1>
1215         friend void
1216         __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
1217                                          const __enable_shared_from_this* __pe,
1218                                          const _Tp1* __px)
1219         {
1220           if (__pe != 0)
1221             __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
1222         }
1223
1224       mutable __weak_ptr<_Tp, _Lp>  _M_weak_this;
1225     };
1226
1227   /**
1228    *  @brief A smart pointer with reference-counted copy semantics.
1229    *
1230    *  The object pointed to is deleted when the last shared_ptr pointing to
1231    *  it is destroyed or reset.
1232    */
1233   template<typename _Tp>
1234     class shared_ptr
1235     : public __shared_ptr<_Tp>
1236     {
1237     public:
1238       shared_ptr()
1239       : __shared_ptr<_Tp>() { }
1240
1241       template<typename _Tp1>
1242         explicit
1243         shared_ptr(_Tp1* __p)
1244         : __shared_ptr<_Tp>(__p) { }
1245
1246       template<typename _Tp1, typename _Deleter>
1247         shared_ptr(_Tp1* __p, _Deleter __d)
1248         : __shared_ptr<_Tp>(__p, __d) { }
1249
1250       template<typename _Tp1, typename _Deleter, typename _Alloc>
1251         shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a)
1252         : __shared_ptr<_Tp>(__p, __d, __a) { }
1253
1254       // Aliasing constructor
1255       template<typename _Tp1>
1256         shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p)
1257         : __shared_ptr<_Tp>(__r, __p) { }
1258
1259       template<typename _Tp1>
1260         shared_ptr(const shared_ptr<_Tp1>& __r)
1261         : __shared_ptr<_Tp>(__r) { }
1262
1263       shared_ptr(shared_ptr&& __r)
1264       : __shared_ptr<_Tp>(std::move(__r)) { }
1265
1266       template<typename _Tp1>
1267         shared_ptr(shared_ptr<_Tp1>&& __r)
1268         : __shared_ptr<_Tp>(std::move(__r)) { }
1269
1270       template<typename _Tp1>
1271         explicit
1272         shared_ptr(const weak_ptr<_Tp1>& __r)
1273         : __shared_ptr<_Tp>(__r) { }
1274
1275 #if _GLIBCXX_DEPRECATED
1276       template<typename _Tp1>
1277         explicit
1278         shared_ptr(std::auto_ptr<_Tp1>&& __r)
1279         : __shared_ptr<_Tp>(std::move(__r)) { }
1280 #endif
1281
1282       template<typename _Tp1, typename _Del>
1283         explicit
1284         shared_ptr(const std::unique_ptr<_Tp1, _Del>&) = delete;
1285
1286       template<typename _Tp1, typename _Del>
1287         explicit
1288         shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
1289         : __shared_ptr<_Tp>(std::move(__r)) { }
1290
1291       template<typename _Tp1>
1292         shared_ptr&
1293         operator=(const shared_ptr<_Tp1>& __r) // never throws
1294         {
1295           this->__shared_ptr<_Tp>::operator=(__r);
1296           return *this;
1297         }
1298
1299 #if _GLIBCXX_DEPRECATED
1300       template<typename _Tp1>
1301         shared_ptr&
1302         operator=(std::auto_ptr<_Tp1>&& __r)
1303         {
1304           this->__shared_ptr<_Tp>::operator=(std::move(__r));
1305           return *this;
1306         }
1307 #endif
1308
1309       shared_ptr&
1310       operator=(shared_ptr&& __r)
1311       {
1312         this->__shared_ptr<_Tp>::operator=(std::move(__r));
1313         return *this;
1314       }
1315
1316       template<class _Tp1>
1317         shared_ptr&
1318         operator=(shared_ptr<_Tp1>&& __r)
1319         {
1320           this->__shared_ptr<_Tp>::operator=(std::move(__r));
1321           return *this;
1322         }
1323
1324       template<typename _Tp1, typename _Del>
1325         shared_ptr&
1326         operator=(const std::unique_ptr<_Tp1, _Del>& __r) = delete;
1327
1328       template<typename _Tp1, typename _Del>
1329         shared_ptr&
1330         operator=(std::unique_ptr<_Tp1, _Del>&& __r)
1331         {
1332           this->__shared_ptr<_Tp>::operator=(std::move(__r));
1333           return *this;
1334         }
1335
1336     private:
1337       // This constructor is non-standard, it is used by allocate_shared.
1338       template<typename _Alloc, typename... _Args>
1339         shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args)
1340         : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
1341         { }
1342
1343       template<typename _Tp1, typename _Alloc, typename... _Args>
1344         friend shared_ptr<_Tp1>
1345         allocate_shared(_Alloc __a, _Args&&... __args);
1346     };
1347
1348   // 20.8.13.2.7 shared_ptr comparisons
1349   template<typename _Tp1, typename _Tp2>
1350     inline bool
1351     operator==(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b)
1352     { return __a.get() == __b.get(); }
1353
1354   template<typename _Tp1, typename _Tp2>
1355     inline bool
1356     operator!=(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b)
1357     { return __a.get() != __b.get(); }
1358
1359   template<typename _Tp1, typename _Tp2>
1360     inline bool
1361     operator<(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b)
1362     { return __a.get() < __b.get(); }
1363
1364   template<typename _Tp>
1365     struct less<shared_ptr<_Tp>>
1366     : public _Sp_less<shared_ptr<_Tp>>
1367     { };
1368
1369   // 20.8.13.2.9 shared_ptr specialized algorithms.
1370   template<typename _Tp>
1371     inline void
1372     swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b)
1373     { __a.swap(__b); }
1374
1375   template<typename _Tp>
1376     inline void
1377     swap(shared_ptr<_Tp>&& __a, shared_ptr<_Tp>& __b)
1378     { __a.swap(__b); }
1379
1380   template<typename _Tp>
1381     inline void
1382     swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>&& __b)
1383     { __a.swap(__b); }
1384
1385   // 20.8.13.2.10 shared_ptr casts.
1386   template<typename _Tp, typename _Tp1>
1387     inline shared_ptr<_Tp>
1388     static_pointer_cast(const shared_ptr<_Tp1>& __r)
1389     { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
1390
1391   template<typename _Tp, typename _Tp1>
1392     inline shared_ptr<_Tp>
1393     const_pointer_cast(const shared_ptr<_Tp1>& __r)
1394     { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
1395
1396   template<typename _Tp, typename _Tp1>
1397     inline shared_ptr<_Tp>
1398     dynamic_pointer_cast(const shared_ptr<_Tp1>& __r)
1399     {
1400       if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
1401         return shared_ptr<_Tp>(__r, __p);
1402       return shared_ptr<_Tp>();
1403     }
1404
1405
1406   /**
1407    *  @brief A smart pointer with weak semantics.
1408    *
1409    *  With forwarding constructors and assignment operators.
1410    */
1411   template<typename _Tp>
1412     class weak_ptr
1413     : public __weak_ptr<_Tp>
1414     {
1415     public:
1416       weak_ptr()
1417       : __weak_ptr<_Tp>() { }
1418
1419       template<typename _Tp1>
1420         weak_ptr(const weak_ptr<_Tp1>& __r)
1421         : __weak_ptr<_Tp>(__r) { }
1422
1423       template<typename _Tp1>
1424         weak_ptr(const shared_ptr<_Tp1>& __r)
1425         : __weak_ptr<_Tp>(__r) { }
1426
1427       template<typename _Tp1>
1428         weak_ptr&
1429         operator=(const weak_ptr<_Tp1>& __r) // never throws
1430         {
1431           this->__weak_ptr<_Tp>::operator=(__r);
1432           return *this;
1433         }
1434
1435       template<typename _Tp1>
1436         weak_ptr&
1437         operator=(const shared_ptr<_Tp1>& __r) // never throws
1438         {
1439           this->__weak_ptr<_Tp>::operator=(__r);
1440           return *this;
1441         }
1442
1443       shared_ptr<_Tp>
1444       lock() const // never throws
1445       {
1446 #ifdef __GTHREADS
1447         if (this->expired())
1448           return shared_ptr<_Tp>();
1449
1450         __try
1451           {
1452             return shared_ptr<_Tp>(*this);
1453           }
1454         __catch(const bad_weak_ptr&)
1455           {
1456             return shared_ptr<_Tp>();
1457           }
1458 #else
1459         return this->expired() ? shared_ptr<_Tp>()
1460                                : shared_ptr<_Tp>(*this);
1461 #endif
1462       }
1463
1464       // comparisons
1465       template<typename _Tp1>
1466         bool operator<(const weak_ptr<_Tp1>&) const = delete;
1467       template<typename _Tp1>
1468         bool operator<=(const weak_ptr<_Tp1>&) const = delete;
1469       template<typename _Tp1>
1470         bool operator>(const weak_ptr<_Tp1>&) const = delete;
1471       template<typename _Tp1>
1472         bool operator>=(const weak_ptr<_Tp1>&) const = delete;
1473     };
1474
1475   // 20.8.13.3.7 weak_ptr specialized algorithms.
1476   template<typename _Tp>
1477     inline void
1478     swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b)
1479     { __a.swap(__b); }
1480
1481   /// owner_less
1482   template<typename _Tp>
1483     struct owner_less<shared_ptr<_Tp>>
1484     : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
1485     { };
1486
1487   template<typename _Tp>
1488     struct owner_less<weak_ptr<_Tp>>
1489     : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
1490     { };
1491
1492   /**
1493    *  @brief Base class allowing use of member function shared_from_this.
1494    */
1495   template<typename _Tp>
1496     class enable_shared_from_this
1497     {
1498     protected:
1499       enable_shared_from_this() { }
1500
1501       enable_shared_from_this(const enable_shared_from_this&) { }
1502
1503       enable_shared_from_this&
1504       operator=(const enable_shared_from_this&)
1505       { return *this; }
1506
1507       ~enable_shared_from_this() { }
1508
1509     public:
1510       shared_ptr<_Tp>
1511       shared_from_this()
1512       { return shared_ptr<_Tp>(this->_M_weak_this); }
1513
1514       shared_ptr<const _Tp>
1515       shared_from_this() const
1516       { return shared_ptr<const _Tp>(this->_M_weak_this); }
1517
1518     private:
1519       template<typename _Tp1>
1520         void
1521         _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const
1522         { _M_weak_this._M_assign(__p, __n); }
1523
1524       template<typename _Tp1>
1525         friend void
1526         __enable_shared_from_this_helper(const __shared_count<>& __pn,
1527                                          const enable_shared_from_this* __pe,
1528                                          const _Tp1* __px)
1529         {
1530           if (__pe != 0)
1531             __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
1532         }
1533
1534       mutable weak_ptr<_Tp>  _M_weak_this;
1535     };
1536
1537   template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
1538     inline __shared_ptr<_Tp, _Lp>
1539     __allocate_shared(_Alloc __a, _Args&&... __args)
1540     {
1541       return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(),
1542           std::forward<_Alloc>(__a), std::forward<_Args>(__args)...);
1543     }
1544
1545   template<typename _Tp, _Lock_policy _Lp, typename... _Args>
1546     inline __shared_ptr<_Tp, _Lp>
1547     __make_shared(_Args&&... __args)
1548     {
1549       typedef typename std::remove_const<_Tp>::type _Tp_nc;
1550       return __allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
1551               std::forward<_Args>(__args)...);
1552     }
1553
1554   /** @brief  Create an object that is owned by a shared_ptr.
1555    *  @param  __a     An allocator.
1556    *  @param  __args  Arguments for the @a _Tp object's constructor.
1557    *  @return A shared_ptr that owns the newly created object.
1558    *  @throw  An exception thrown from @a _Alloc::allocate or from the
1559    *          constructor of @a _Tp.
1560    *
1561    *  A copy of @a __a will be used to allocate memory for the shared_ptr
1562    *  and the new object.
1563    */
1564   template<typename _Tp, typename _Alloc, typename... _Args>
1565     inline shared_ptr<_Tp>
1566     allocate_shared(_Alloc __a, _Args&&... __args)
1567     {
1568       return shared_ptr<_Tp>(_Sp_make_shared_tag(), std::forward<_Alloc>(__a),
1569               std::forward<_Args>(__args)...);
1570     }
1571
1572   /** @brief  Create an object that is owned by a shared_ptr.
1573    *  @param  __args  Arguments for the @a _Tp object's constructor.
1574    *  @return A shared_ptr that owns the newly created object.
1575    *  @throw  std::bad_alloc, or an exception thrown from the
1576    *          constructor of @a _Tp.
1577    */
1578   template<typename _Tp, typename... _Args>
1579     inline shared_ptr<_Tp>
1580     make_shared(_Args&&... __args)
1581     {
1582       typedef typename std::remove_const<_Tp>::type _Tp_nc;
1583       return allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
1584               std::forward<_Args>(__args)...);
1585     }
1586
1587   // @} group pointer_abstractions
1588
1589 _GLIBCXX_END_NAMESPACE
1590
1591 #endif // _SHARED_PTR_H