Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. // shared_ptr and weak_ptr implementation details -*- C++ -*-
  2.  
  3. // Copyright (C) 2007-2013 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.  *  Do not attempt to use it directly. @headername{memory}
  47.  */
  48.  
  49. #ifndef _SHARED_PTR_BASE_H
  50. #define _SHARED_PTR_BASE_H 1
  51.  
  52. namespace std _GLIBCXX_VISIBILITY(default)
  53. {
  54. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  55.  
  56. #if _GLIBCXX_USE_DEPRECATED
  57.   template<typename> class auto_ptr;
  58. #endif
  59.  
  60.  /**
  61.    *  @brief  Exception possibly thrown by @c shared_ptr.
  62.    *  @ingroup exceptions
  63.    */
  64.   class bad_weak_ptr : public std::exception
  65.   {
  66.   public:
  67.     virtual char const*
  68.     what() const noexcept;
  69.  
  70.     virtual ~bad_weak_ptr() noexcept;    
  71.   };
  72.  
  73.   // Substitute for bad_weak_ptr object in the case of -fno-exceptions.
  74.   inline void
  75.   __throw_bad_weak_ptr()
  76.   { _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr()); }
  77.  
  78.   using __gnu_cxx::_Lock_policy;
  79.   using __gnu_cxx::__default_lock_policy;
  80.   using __gnu_cxx::_S_single;
  81.   using __gnu_cxx::_S_mutex;
  82.   using __gnu_cxx::_S_atomic;
  83.  
  84.   // Empty helper class except when the template argument is _S_mutex.
  85.   template<_Lock_policy _Lp>
  86.     class _Mutex_base
  87.     {
  88.     protected:
  89.       // The atomic policy uses fully-fenced builtins, single doesn't care.
  90.       enum { _S_need_barriers = 0 };
  91.     };
  92.  
  93.   template<>
  94.     class _Mutex_base<_S_mutex>
  95.     : public __gnu_cxx::__mutex
  96.     {
  97.     protected:
  98.       // This policy is used when atomic builtins are not available.
  99.       // The replacement atomic operations might not have the necessary
  100.       // memory barriers.
  101.       enum { _S_need_barriers = 1 };
  102.     };
  103.  
  104.   template<_Lock_policy _Lp = __default_lock_policy>
  105.     class _Sp_counted_base
  106.     : public _Mutex_base<_Lp>
  107.     {
  108.     public:  
  109.       _Sp_counted_base() noexcept
  110.       : _M_use_count(1), _M_weak_count(1) { }
  111.      
  112.       virtual
  113.       ~_Sp_counted_base() noexcept
  114.       { }
  115.  
  116.       // Called when _M_use_count drops to zero, to release the resources
  117.       // managed by *this.
  118.       virtual void
  119.       _M_dispose() noexcept = 0;
  120.      
  121.       // Called when _M_weak_count drops to zero.
  122.       virtual void
  123.       _M_destroy() noexcept
  124.       { delete this; }
  125.      
  126.       virtual void*
  127.       _M_get_deleter(const std::type_info&) = 0;
  128.  
  129.       void
  130.       _M_add_ref_copy()
  131.       { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
  132.  
  133.       void
  134.       _M_add_ref_lock();
  135.      
  136.       void
  137.       _M_release() noexcept
  138.       {
  139.         // Be race-detector-friendly.  For more info see bits/c++config.
  140.         _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
  141.         if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
  142.           {
  143.             _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
  144.             _M_dispose();
  145.             // There must be a memory barrier between dispose() and destroy()
  146.             // to ensure that the effects of dispose() are observed in the
  147.             // thread that runs destroy().
  148.             // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
  149.             if (_Mutex_base<_Lp>::_S_need_barriers)
  150.               {
  151.                 _GLIBCXX_READ_MEM_BARRIER;
  152.                 _GLIBCXX_WRITE_MEM_BARRIER;
  153.               }
  154.  
  155.             // Be race-detector-friendly.  For more info see bits/c++config.
  156.             _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
  157.             if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
  158.                                                        -1) == 1)
  159.               {
  160.                 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
  161.                 _M_destroy();
  162.               }
  163.           }
  164.       }
  165.  
  166.       void
  167.       _M_weak_add_ref() noexcept
  168.       { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
  169.  
  170.       void
  171.       _M_weak_release() noexcept
  172.       {
  173.         // Be race-detector-friendly. For more info see bits/c++config.
  174.         _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
  175.         if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
  176.           {
  177.             _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
  178.             if (_Mutex_base<_Lp>::_S_need_barriers)
  179.               {
  180.                 // See _M_release(),
  181.                 // destroy() must observe results of dispose()
  182.                 _GLIBCXX_READ_MEM_BARRIER;
  183.                 _GLIBCXX_WRITE_MEM_BARRIER;
  184.               }
  185.             _M_destroy();
  186.           }
  187.       }
  188.  
  189.       long
  190.       _M_get_use_count() const noexcept
  191.       {
  192.         // No memory barrier is used here so there is no synchronization
  193.         // with other threads.
  194.         return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED);
  195.       }
  196.  
  197.     private:  
  198.       _Sp_counted_base(_Sp_counted_base const&) = delete;
  199.       _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
  200.  
  201.       _Atomic_word  _M_use_count;     // #shared
  202.       _Atomic_word  _M_weak_count;    // #weak + (#shared != 0)
  203.     };
  204.  
  205.   template<>
  206.     inline void
  207.     _Sp_counted_base<_S_single>::
  208.     _M_add_ref_lock()
  209.     {
  210.       if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
  211.         {
  212.           _M_use_count = 0;
  213.           __throw_bad_weak_ptr();
  214.         }
  215.     }
  216.  
  217.   template<>
  218.     inline void
  219.     _Sp_counted_base<_S_mutex>::
  220.     _M_add_ref_lock()
  221.     {
  222.       __gnu_cxx::__scoped_lock sentry(*this);
  223.       if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
  224.         {
  225.           _M_use_count = 0;
  226.           __throw_bad_weak_ptr();
  227.         }
  228.     }
  229.  
  230.   template<>
  231.     inline void
  232.     _Sp_counted_base<_S_atomic>::
  233.     _M_add_ref_lock()
  234.     {
  235.       // Perform lock-free add-if-not-zero operation.
  236.       _Atomic_word __count = _M_use_count;
  237.       do
  238.         {
  239.           if (__count == 0)
  240.             __throw_bad_weak_ptr();
  241.           // Replace the current counter value with the old value + 1, as
  242.           // long as it's not changed meanwhile.
  243.         }
  244.       while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
  245.                                           true, __ATOMIC_ACQ_REL,
  246.                                           __ATOMIC_RELAXED));
  247.     }
  248.  
  249.  
  250.   // Forward declarations.
  251.   template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  252.     class __shared_ptr;
  253.  
  254.   template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  255.     class __weak_ptr;
  256.  
  257.   template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
  258.     class __enable_shared_from_this;
  259.  
  260.   template<typename _Tp>
  261.     class shared_ptr;
  262.  
  263.   template<typename _Tp>
  264.     class weak_ptr;
  265.  
  266.   template<typename _Tp>
  267.     struct owner_less;
  268.  
  269.   template<typename _Tp>
  270.     class enable_shared_from_this;
  271.  
  272.   template<_Lock_policy _Lp = __default_lock_policy>
  273.     class __weak_count;
  274.  
  275.   template<_Lock_policy _Lp = __default_lock_policy>
  276.     class __shared_count;
  277.  
  278.  
  279.   // Counted ptr with no deleter or allocator support
  280.   template<typename _Ptr, _Lock_policy _Lp>
  281.     class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
  282.     {
  283.     public:
  284.       explicit
  285.       _Sp_counted_ptr(_Ptr __p)
  286.       : _M_ptr(__p) { }
  287.  
  288.       virtual void
  289.       _M_dispose() noexcept
  290.       { delete _M_ptr; }
  291.  
  292.       virtual void
  293.       _M_destroy() noexcept
  294.       { delete this; }
  295.  
  296.       virtual void*
  297.       _M_get_deleter(const std::type_info&)
  298.       { return 0; }
  299.  
  300.       _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
  301.       _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
  302.  
  303.     protected:
  304.       _Ptr             _M_ptr;  // copy constructor must not throw
  305.     };
  306.  
  307.   template<>
  308.     inline void
  309.     _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }
  310.  
  311.   template<>
  312.     inline void
  313.     _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }
  314.  
  315.   template<>
  316.     inline void
  317.     _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }
  318.  
  319.   // Support for custom deleter and/or allocator
  320.   template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
  321.     class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
  322.     {
  323.       // Helper class that stores the Deleter and also acts as an allocator.
  324.       // Used to dispose of the owned pointer and the internal refcount
  325.       // Requires that copies of _Alloc can free each other's memory.
  326.       struct _My_Deleter
  327.       : public _Alloc           // copy constructor must not throw
  328.       {
  329.         _Deleter _M_del;        // copy constructor must not throw
  330.         _My_Deleter(_Deleter __d, const _Alloc& __a)
  331.         : _Alloc(__a), _M_del(__d) { }
  332.       };
  333.  
  334.     public:
  335.       // __d(__p) must not throw.
  336.       _Sp_counted_deleter(_Ptr __p, _Deleter __d)
  337.       : _M_ptr(__p), _M_del(__d, _Alloc()) { }
  338.  
  339.       // __d(__p) must not throw.
  340.       _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a)
  341.       : _M_ptr(__p), _M_del(__d, __a) { }
  342.  
  343.       ~_Sp_counted_deleter() noexcept { }
  344.  
  345.       virtual void
  346.       _M_dispose() noexcept
  347.       { _M_del._M_del(_M_ptr); }
  348.  
  349.       virtual void
  350.       _M_destroy() noexcept
  351.       {
  352.         typedef typename allocator_traits<_Alloc>::template
  353.           rebind_traits<_Sp_counted_deleter> _Alloc_traits;
  354.         typename _Alloc_traits::allocator_type __a(_M_del);
  355.         _Alloc_traits::destroy(__a, this);
  356.         _Alloc_traits::deallocate(__a, this, 1);
  357.       }
  358.  
  359.       virtual void*
  360.       _M_get_deleter(const std::type_info& __ti)
  361.       {
  362. #ifdef __GXX_RTTI
  363.         return __ti == typeid(_Deleter) ? &_M_del._M_del : 0;
  364. #else
  365.         return 0;
  366. #endif
  367.       }
  368.  
  369.     protected:
  370.       _Ptr             _M_ptr;  // copy constructor must not throw
  371.       _My_Deleter      _M_del;  // copy constructor must not throw
  372.     };
  373.  
  374.   // helpers for make_shared / allocate_shared
  375.  
  376.   struct _Sp_make_shared_tag { };
  377.  
  378.   template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
  379.     class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
  380.     {
  381.       // Helper class that stores the pointer and also acts as an allocator.
  382.       // Used to dispose of the owned pointer and the internal refcount
  383.       // Requires that copies of _Alloc can free each other's memory.
  384.       struct _Impl
  385.       : public _Alloc           // copy constructor must not throw
  386.       {
  387.         _Impl(_Alloc __a) : _Alloc(__a), _M_ptr() { }
  388.         _Tp* _M_ptr;
  389.       };
  390.  
  391.     public:
  392.       template<typename... _Args>
  393.         _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
  394.         : _M_impl(__a), _M_storage()
  395.         {
  396.           _M_impl._M_ptr = static_cast<_Tp*>(static_cast<void*>(&_M_storage));
  397.           // _GLIBCXX_RESOLVE_LIB_DEFECTS
  398.           // 2070.  allocate_shared should use allocator_traits<A>::construct
  399.           allocator_traits<_Alloc>::construct(__a, _M_impl._M_ptr,
  400.               std::forward<_Args>(__args)...); // might throw
  401.         }
  402.  
  403.       ~_Sp_counted_ptr_inplace() noexcept { }
  404.  
  405.       virtual void
  406.       _M_dispose() noexcept
  407.       { allocator_traits<_Alloc>::destroy(_M_impl, _M_impl._M_ptr); }
  408.  
  409.       // Override because the allocator needs to know the dynamic type
  410.       virtual void
  411.       _M_destroy() noexcept
  412.       {
  413.         typedef typename allocator_traits<_Alloc>::template
  414.           rebind_traits<_Sp_counted_ptr_inplace> _Alloc_traits;
  415.         typename _Alloc_traits::allocator_type __a(_M_impl);
  416.         _Alloc_traits::destroy(__a, this);
  417.         _Alloc_traits::deallocate(__a, this, 1);
  418.       }
  419.  
  420.       // Sneaky trick so __shared_ptr can get the managed pointer
  421.       virtual void*
  422.       _M_get_deleter(const std::type_info& __ti) noexcept
  423.       {
  424. #ifdef __GXX_RTTI
  425.         return __ti == typeid(_Sp_make_shared_tag)
  426.                ? static_cast<void*>(&_M_storage)
  427.                : 0;
  428. #else
  429.         return 0;
  430. #endif
  431.       }
  432.  
  433.     private:
  434.       _Impl _M_impl;
  435.       typename aligned_storage<sizeof(_Tp), alignment_of<_Tp>::value>::type
  436.         _M_storage;
  437.     };
  438.  
  439.   template<_Lock_policy _Lp>
  440.     class __shared_count
  441.     {
  442.     public:
  443.       constexpr __shared_count() noexcept : _M_pi(0)
  444.       { }
  445.  
  446.       template<typename _Ptr>
  447.         explicit
  448.         __shared_count(_Ptr __p) : _M_pi(0)
  449.         {
  450.           __try
  451.             {
  452.               _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
  453.             }
  454.           __catch(...)
  455.             {
  456.               delete __p;
  457.               __throw_exception_again;
  458.             }
  459.         }
  460.  
  461.       template<typename _Ptr, typename _Deleter>
  462.         __shared_count(_Ptr __p, _Deleter __d)
  463.         : __shared_count(__p, std::move(__d), allocator<int>())
  464.         { }
  465.  
  466.       template<typename _Ptr, typename _Deleter, typename _Alloc>
  467.         __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
  468.         {
  469.           typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
  470.           typedef typename allocator_traits<_Alloc>::template
  471.             rebind_traits<_Sp_cd_type> _Alloc_traits;
  472.           typename _Alloc_traits::allocator_type __a2(__a);
  473.           _Sp_cd_type* __mem = 0;
  474.           __try
  475.             {
  476.               __mem = _Alloc_traits::allocate(__a2, 1);
  477.               _Alloc_traits::construct(__a2, __mem,
  478.                   __p, std::move(__d), std::move(__a));
  479.               _M_pi = __mem;
  480.             }
  481.           __catch(...)
  482.             {
  483.               __d(__p); // Call _Deleter on __p.
  484.               if (__mem)
  485.                 _Alloc_traits::deallocate(__a2, __mem, 1);
  486.               __throw_exception_again;
  487.             }
  488.         }
  489.  
  490.       template<typename _Tp, typename _Alloc, typename... _Args>
  491.         __shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
  492.                        _Args&&... __args)
  493.         : _M_pi(0)
  494.         {
  495.           typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
  496.           typedef typename allocator_traits<_Alloc>::template
  497.             rebind_traits<_Sp_cp_type> _Alloc_traits;
  498.           typename _Alloc_traits::allocator_type __a2(__a);
  499.           _Sp_cp_type* __mem = _Alloc_traits::allocate(__a2, 1);
  500.           __try
  501.             {
  502.               _Alloc_traits::construct(__a2, __mem, std::move(__a),
  503.                     std::forward<_Args>(__args)...);
  504.               _M_pi = __mem;
  505.             }
  506.           __catch(...)
  507.             {
  508.               _Alloc_traits::deallocate(__a2, __mem, 1);
  509.               __throw_exception_again;
  510.             }
  511.         }
  512.  
  513. #if _GLIBCXX_USE_DEPRECATED
  514.       // Special case for auto_ptr<_Tp> to provide the strong guarantee.
  515.       template<typename _Tp>
  516.         explicit
  517.         __shared_count(std::auto_ptr<_Tp>&& __r);
  518. #endif
  519.  
  520.       // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
  521.       template<typename _Tp, typename _Del>
  522.         explicit
  523.         __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
  524.         {
  525.           using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
  526.           using _Del2 = typename conditional<is_reference<_Del>::value,
  527.               reference_wrapper<typename remove_reference<_Del>::type>,
  528.               _Del>::type;
  529.           using _Sp_cd_type
  530.             = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
  531.           using _Alloc = allocator<_Sp_cd_type>;
  532.           using _Alloc_traits = allocator_traits<_Alloc>;
  533.           _Alloc __a;
  534.           _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
  535.           _Alloc_traits::construct(__a, __mem, __r.release(),
  536.                                    __r.get_deleter());  // non-throwing
  537.           _M_pi = __mem;
  538.         }
  539.  
  540.       // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
  541.       explicit __shared_count(const __weak_count<_Lp>& __r);
  542.  
  543.       ~__shared_count() noexcept
  544.       {
  545.         if (_M_pi != nullptr)
  546.           _M_pi->_M_release();
  547.       }
  548.  
  549.       __shared_count(const __shared_count& __r) noexcept
  550.       : _M_pi(__r._M_pi)
  551.       {
  552.         if (_M_pi != 0)
  553.           _M_pi->_M_add_ref_copy();
  554.       }
  555.  
  556.       __shared_count&
  557.       operator=(const __shared_count& __r) noexcept
  558.       {
  559.         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
  560.         if (__tmp != _M_pi)
  561.           {
  562.             if (__tmp != 0)
  563.               __tmp->_M_add_ref_copy();
  564.             if (_M_pi != 0)
  565.               _M_pi->_M_release();
  566.             _M_pi = __tmp;
  567.           }
  568.         return *this;
  569.       }
  570.  
  571.       void
  572.       _M_swap(__shared_count& __r) noexcept
  573.       {
  574.         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
  575.         __r._M_pi = _M_pi;
  576.         _M_pi = __tmp;
  577.       }
  578.  
  579.       long
  580.       _M_get_use_count() const noexcept
  581.       { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
  582.  
  583.       bool
  584.       _M_unique() const noexcept
  585.       { return this->_M_get_use_count() == 1; }
  586.  
  587.       void*
  588.       _M_get_deleter(const std::type_info& __ti) const noexcept
  589.       { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; }
  590.  
  591.       bool
  592.       _M_less(const __shared_count& __rhs) const noexcept
  593.       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
  594.  
  595.       bool
  596.       _M_less(const __weak_count<_Lp>& __rhs) const noexcept
  597.       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
  598.  
  599.       // Friend function injected into enclosing namespace and found by ADL
  600.       friend inline bool
  601.       operator==(const __shared_count& __a, const __shared_count& __b) noexcept
  602.       { return __a._M_pi == __b._M_pi; }
  603.  
  604.     private:
  605.       friend class __weak_count<_Lp>;
  606.  
  607.       _Sp_counted_base<_Lp>*  _M_pi;
  608.     };
  609.  
  610.  
  611.   template<_Lock_policy _Lp>
  612.     class __weak_count
  613.     {
  614.     public:
  615.       constexpr __weak_count() noexcept : _M_pi(0)
  616.       { }
  617.  
  618.       __weak_count(const __shared_count<_Lp>& __r) noexcept
  619.       : _M_pi(__r._M_pi)
  620.       {
  621.         if (_M_pi != 0)
  622.           _M_pi->_M_weak_add_ref();
  623.       }
  624.  
  625.       __weak_count(const __weak_count<_Lp>& __r) noexcept
  626.       : _M_pi(__r._M_pi)
  627.       {
  628.         if (_M_pi != 0)
  629.           _M_pi->_M_weak_add_ref();
  630.       }
  631.  
  632.       ~__weak_count() noexcept
  633.       {
  634.         if (_M_pi != 0)
  635.           _M_pi->_M_weak_release();
  636.       }
  637.  
  638.       __weak_count<_Lp>&
  639.       operator=(const __shared_count<_Lp>& __r) noexcept
  640.       {
  641.         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
  642.         if (__tmp != 0)
  643.           __tmp->_M_weak_add_ref();
  644.         if (_M_pi != 0)
  645.           _M_pi->_M_weak_release();
  646.         _M_pi = __tmp;
  647.         return *this;
  648.       }
  649.  
  650.       __weak_count<_Lp>&
  651.       operator=(const __weak_count<_Lp>& __r) noexcept
  652.       {
  653.         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
  654.         if (__tmp != 0)
  655.           __tmp->_M_weak_add_ref();
  656.         if (_M_pi != 0)
  657.           _M_pi->_M_weak_release();
  658.         _M_pi = __tmp;
  659.         return *this;
  660.       }
  661.  
  662.       void
  663.       _M_swap(__weak_count<_Lp>& __r) noexcept
  664.       {
  665.         _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
  666.         __r._M_pi = _M_pi;
  667.         _M_pi = __tmp;
  668.       }
  669.  
  670.       long
  671.       _M_get_use_count() const noexcept
  672.       { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
  673.  
  674.       bool
  675.       _M_less(const __weak_count& __rhs) const noexcept
  676.       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
  677.  
  678.       bool
  679.       _M_less(const __shared_count<_Lp>& __rhs) const noexcept
  680.       { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
  681.  
  682.       // Friend function injected into enclosing namespace and found by ADL
  683.       friend inline bool
  684.       operator==(const __weak_count& __a, const __weak_count& __b) noexcept
  685.       { return __a._M_pi == __b._M_pi; }
  686.  
  687.     private:
  688.       friend class __shared_count<_Lp>;
  689.  
  690.       _Sp_counted_base<_Lp>*  _M_pi;
  691.     };
  692.  
  693.   // Now that __weak_count is defined we can define this constructor:
  694.   template<_Lock_policy _Lp>
  695.     inline __shared_count<_Lp>:: __shared_count(const __weak_count<_Lp>& __r)
  696.     : _M_pi(__r._M_pi)
  697.     {
  698.       if (_M_pi != 0)
  699.         _M_pi->_M_add_ref_lock();
  700.       else
  701.         __throw_bad_weak_ptr();
  702.     }
  703.  
  704.  
  705.   // Support for enable_shared_from_this.
  706.  
  707.   // Friend of __enable_shared_from_this.
  708.   template<_Lock_policy _Lp, typename _Tp1, typename _Tp2>
  709.     void
  710.     __enable_shared_from_this_helper(const __shared_count<_Lp>&,
  711.                                      const __enable_shared_from_this<_Tp1,
  712.                                      _Lp>*, const _Tp2*) noexcept;
  713.  
  714.   // Friend of enable_shared_from_this.
  715.   template<typename _Tp1, typename _Tp2>
  716.     void
  717.     __enable_shared_from_this_helper(const __shared_count<>&,
  718.                                      const enable_shared_from_this<_Tp1>*,
  719.                                      const _Tp2*) noexcept;
  720.  
  721.   template<_Lock_policy _Lp>
  722.     inline void
  723.     __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) noexcept
  724.     { }
  725.  
  726.  
  727.   template<typename _Tp, _Lock_policy _Lp>
  728.     class __shared_ptr
  729.     {
  730.     public:
  731.       typedef _Tp   element_type;
  732.  
  733.       constexpr __shared_ptr() noexcept
  734.       : _M_ptr(0), _M_refcount()
  735.       { }
  736.  
  737.       template<typename _Tp1>
  738.         explicit __shared_ptr(_Tp1* __p)
  739.         : _M_ptr(__p), _M_refcount(__p)
  740.         {
  741.           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
  742.           static_assert( sizeof(_Tp1) > 0, "incomplete type" );
  743.           __enable_shared_from_this_helper(_M_refcount, __p, __p);
  744.         }
  745.  
  746.       template<typename _Tp1, typename _Deleter>
  747.         __shared_ptr(_Tp1* __p, _Deleter __d)
  748.         : _M_ptr(__p), _M_refcount(__p, __d)
  749.         {
  750.           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
  751.           // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
  752.           __enable_shared_from_this_helper(_M_refcount, __p, __p);
  753.         }
  754.  
  755.       template<typename _Tp1, typename _Deleter, typename _Alloc>
  756.         __shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
  757.         : _M_ptr(__p), _M_refcount(__p, __d, std::move(__a))
  758.         {
  759.           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
  760.           // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
  761.           __enable_shared_from_this_helper(_M_refcount, __p, __p);
  762.         }
  763.  
  764.       template<typename _Deleter>
  765.         __shared_ptr(nullptr_t __p, _Deleter __d)
  766.         : _M_ptr(0), _M_refcount(__p, __d)
  767.         { }
  768.  
  769.       template<typename _Deleter, typename _Alloc>
  770.         __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
  771.         : _M_ptr(0), _M_refcount(__p, __d, std::move(__a))
  772.         { }
  773.  
  774.       template<typename _Tp1>
  775.         __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) noexcept
  776.         : _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
  777.         { }
  778.  
  779.       __shared_ptr(const __shared_ptr&) noexcept = default;
  780.       __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
  781.       ~__shared_ptr() = default;
  782.  
  783.       template<typename _Tp1, typename = typename
  784.                std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
  785.         __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  786.         : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
  787.         { }
  788.  
  789.       __shared_ptr(__shared_ptr&& __r) noexcept
  790.       : _M_ptr(__r._M_ptr), _M_refcount()
  791.       {
  792.         _M_refcount._M_swap(__r._M_refcount);
  793.         __r._M_ptr = 0;
  794.       }
  795.  
  796.       template<typename _Tp1, typename = typename
  797.                std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
  798.         __shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
  799.         : _M_ptr(__r._M_ptr), _M_refcount()
  800.         {
  801.           _M_refcount._M_swap(__r._M_refcount);
  802.           __r._M_ptr = 0;
  803.         }
  804.  
  805.       template<typename _Tp1>
  806.         explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
  807.         : _M_refcount(__r._M_refcount) // may throw
  808.         {
  809.           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
  810.  
  811.           // It is now safe to copy __r._M_ptr, as
  812.           // _M_refcount(__r._M_refcount) did not throw.
  813.           _M_ptr = __r._M_ptr;
  814.         }
  815.  
  816.       // If an exception is thrown this constructor has no effect.
  817.       template<typename _Tp1, typename _Del>
  818.         __shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
  819.         : _M_ptr(__r.get()), _M_refcount()
  820.         {
  821.           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
  822.           auto __tmp = std::__addressof(*__r.get());
  823.           _M_refcount = __shared_count<_Lp>(std::move(__r));
  824.           __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
  825.         }
  826.  
  827. #if _GLIBCXX_USE_DEPRECATED
  828.       // Postcondition: use_count() == 1 and __r.get() == 0
  829.       template<typename _Tp1>
  830.         __shared_ptr(std::auto_ptr<_Tp1>&& __r);
  831. #endif
  832.  
  833.       /* TODO: use delegating constructor */
  834.       constexpr __shared_ptr(nullptr_t) noexcept
  835.       : _M_ptr(0), _M_refcount()
  836.       { }
  837.  
  838.       template<typename _Tp1>
  839.         __shared_ptr&
  840.         operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  841.         {
  842.           _M_ptr = __r._M_ptr;
  843.           _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
  844.           return *this;
  845.         }
  846.  
  847. #if _GLIBCXX_USE_DEPRECATED
  848.       template<typename _Tp1>
  849.         __shared_ptr&
  850.         operator=(std::auto_ptr<_Tp1>&& __r)
  851.         {
  852.           __shared_ptr(std::move(__r)).swap(*this);
  853.           return *this;
  854.         }
  855. #endif
  856.  
  857.       __shared_ptr&
  858.       operator=(__shared_ptr&& __r) noexcept
  859.       {
  860.         __shared_ptr(std::move(__r)).swap(*this);
  861.         return *this;
  862.       }
  863.  
  864.       template<class _Tp1>
  865.         __shared_ptr&
  866.         operator=(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
  867.         {
  868.           __shared_ptr(std::move(__r)).swap(*this);
  869.           return *this;
  870.         }
  871.  
  872.       template<typename _Tp1, typename _Del>
  873.         __shared_ptr&
  874.         operator=(std::unique_ptr<_Tp1, _Del>&& __r)
  875.         {
  876.           __shared_ptr(std::move(__r)).swap(*this);
  877.           return *this;
  878.         }
  879.  
  880.       void
  881.       reset() noexcept
  882.       { __shared_ptr().swap(*this); }
  883.  
  884.       template<typename _Tp1>
  885.         void
  886.         reset(_Tp1* __p) // _Tp1 must be complete.
  887.         {
  888.           // Catch self-reset errors.
  889.           _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr);
  890.           __shared_ptr(__p).swap(*this);
  891.         }
  892.  
  893.       template<typename _Tp1, typename _Deleter>
  894.         void
  895.         reset(_Tp1* __p, _Deleter __d)
  896.         { __shared_ptr(__p, __d).swap(*this); }
  897.  
  898.       template<typename _Tp1, typename _Deleter, typename _Alloc>
  899.         void
  900.         reset(_Tp1* __p, _Deleter __d, _Alloc __a)
  901.         { __shared_ptr(__p, __d, std::move(__a)).swap(*this); }
  902.  
  903.       // Allow class instantiation when _Tp is [cv-qual] void.
  904.       typename std::add_lvalue_reference<_Tp>::type
  905.       operator*() const noexcept
  906.       {
  907.         _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
  908.         return *_M_ptr;
  909.       }
  910.  
  911.       _Tp*
  912.       operator->() const noexcept
  913.       {
  914.         _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
  915.         return _M_ptr;
  916.       }
  917.  
  918.       _Tp*
  919.       get() const noexcept
  920.       { return _M_ptr; }
  921.  
  922.       explicit operator bool() const // never throws
  923.       { return _M_ptr == 0 ? false : true; }
  924.  
  925.       bool
  926.       unique() const noexcept
  927.       { return _M_refcount._M_unique(); }
  928.  
  929.       long
  930.       use_count() const noexcept
  931.       { return _M_refcount._M_get_use_count(); }
  932.  
  933.       void
  934.       swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
  935.       {
  936.         std::swap(_M_ptr, __other._M_ptr);
  937.         _M_refcount._M_swap(__other._M_refcount);
  938.       }
  939.  
  940.       template<typename _Tp1>
  941.         bool
  942.         owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
  943.         { return _M_refcount._M_less(__rhs._M_refcount); }
  944.  
  945.       template<typename _Tp1>
  946.         bool
  947.         owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
  948.         { return _M_refcount._M_less(__rhs._M_refcount); }
  949.  
  950. #ifdef __GXX_RTTI
  951.     protected:
  952.       // This constructor is non-standard, it is used by allocate_shared.
  953.       template<typename _Alloc, typename... _Args>
  954.         __shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
  955.                      _Args&&... __args)
  956.         : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
  957.                                 std::forward<_Args>(__args)...)
  958.         {
  959.           // _M_ptr needs to point to the newly constructed object.
  960.           // This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
  961.           void* __p = _M_refcount._M_get_deleter(typeid(__tag));
  962.           _M_ptr = static_cast<_Tp*>(__p);
  963.           __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
  964.         }
  965. #else
  966.       template<typename _Alloc>
  967.         struct _Deleter
  968.         {
  969.           void operator()(_Tp* __ptr)
  970.           {
  971.             typedef allocator_traits<_Alloc> _Alloc_traits;
  972.             _Alloc_traits::destroy(_M_alloc, __ptr);
  973.             _Alloc_traits::deallocate(_M_alloc, __ptr, 1);
  974.           }
  975.           _Alloc _M_alloc;
  976.         };
  977.  
  978.       template<typename _Alloc, typename... _Args>
  979.         __shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
  980.                      _Args&&... __args)
  981.         : _M_ptr(), _M_refcount()
  982.         {
  983.           typedef typename _Alloc::template rebind<_Tp>::other _Alloc2;
  984.           _Deleter<_Alloc2> __del = { _Alloc2(__a) };
  985.           typedef allocator_traits<_Alloc2> __traits;
  986.           _M_ptr = __traits::allocate(__del._M_alloc, 1);
  987.           __try
  988.             {
  989.               // _GLIBCXX_RESOLVE_LIB_DEFECTS
  990.               // 2070. allocate_shared should use allocator_traits<A>::construct
  991.               __traits::construct(__del._M_alloc, _M_ptr,
  992.                                   std::forward<_Args>(__args)...);
  993.             }
  994.           __catch(...)
  995.             {
  996.               __traits::deallocate(__del._M_alloc, _M_ptr, 1);
  997.               __throw_exception_again;
  998.             }
  999.           __shared_count<_Lp> __count(_M_ptr, __del, __del._M_alloc);
  1000.           _M_refcount._M_swap(__count);
  1001.           __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
  1002.         }
  1003. #endif
  1004.  
  1005.       template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
  1006.                typename... _Args>
  1007.         friend __shared_ptr<_Tp1, _Lp1>
  1008.         __allocate_shared(const _Alloc& __a, _Args&&... __args);
  1009.  
  1010.     private:
  1011.       void*
  1012.       _M_get_deleter(const std::type_info& __ti) const noexcept
  1013.       { return _M_refcount._M_get_deleter(__ti); }
  1014.  
  1015.       template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
  1016.       template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
  1017.  
  1018.       template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
  1019.         friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
  1020.  
  1021.       _Tp*                 _M_ptr;         // Contained pointer.
  1022.       __shared_count<_Lp>  _M_refcount;    // Reference counter.
  1023.     };
  1024.  
  1025.  
  1026.   // 20.7.2.2.7 shared_ptr comparisons
  1027.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  1028.     inline bool
  1029.     operator==(const __shared_ptr<_Tp1, _Lp>& __a,
  1030.                const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  1031.     { return __a.get() == __b.get(); }
  1032.  
  1033.   template<typename _Tp, _Lock_policy _Lp>
  1034.     inline bool
  1035.     operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  1036.     { return !__a; }
  1037.  
  1038.   template<typename _Tp, _Lock_policy _Lp>
  1039.     inline bool
  1040.     operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  1041.     { return !__a; }
  1042.  
  1043.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  1044.     inline bool
  1045.     operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
  1046.                const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  1047.     { return __a.get() != __b.get(); }
  1048.  
  1049.   template<typename _Tp, _Lock_policy _Lp>
  1050.     inline bool
  1051.     operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  1052.     { return (bool)__a; }
  1053.  
  1054.   template<typename _Tp, _Lock_policy _Lp>
  1055.     inline bool
  1056.     operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  1057.     { return (bool)__a; }
  1058.  
  1059.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  1060.     inline bool
  1061.     operator<(const __shared_ptr<_Tp1, _Lp>& __a,
  1062.               const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  1063.     {
  1064.       typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
  1065.       return std::less<_CT>()(__a.get(), __b.get());
  1066.     }
  1067.  
  1068.   template<typename _Tp, _Lock_policy _Lp>
  1069.     inline bool
  1070.     operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  1071.     { return std::less<_Tp*>()(__a.get(), nullptr); }
  1072.  
  1073.   template<typename _Tp, _Lock_policy _Lp>
  1074.     inline bool
  1075.     operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  1076.     { return std::less<_Tp*>()(nullptr, __a.get()); }
  1077.  
  1078.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  1079.     inline bool
  1080.     operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
  1081.                const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  1082.     { return !(__b < __a); }
  1083.  
  1084.   template<typename _Tp, _Lock_policy _Lp>
  1085.     inline bool
  1086.     operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  1087.     { return !(nullptr < __a); }
  1088.  
  1089.   template<typename _Tp, _Lock_policy _Lp>
  1090.     inline bool
  1091.     operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  1092.     { return !(__a < nullptr); }
  1093.  
  1094.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  1095.     inline bool
  1096.     operator>(const __shared_ptr<_Tp1, _Lp>& __a,
  1097.               const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  1098.     { return (__b < __a); }
  1099.  
  1100.   template<typename _Tp, _Lock_policy _Lp>
  1101.     inline bool
  1102.     operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  1103.     { return std::less<_Tp*>()(nullptr, __a.get()); }
  1104.  
  1105.   template<typename _Tp, _Lock_policy _Lp>
  1106.     inline bool
  1107.     operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  1108.     { return std::less<_Tp*>()(__a.get(), nullptr); }
  1109.  
  1110.   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
  1111.     inline bool
  1112.     operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
  1113.                const __shared_ptr<_Tp2, _Lp>& __b) noexcept
  1114.     { return !(__a < __b); }
  1115.  
  1116.   template<typename _Tp, _Lock_policy _Lp>
  1117.     inline bool
  1118.     operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
  1119.     { return !(__a < nullptr); }
  1120.  
  1121.   template<typename _Tp, _Lock_policy _Lp>
  1122.     inline bool
  1123.     operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
  1124.     { return !(nullptr < __a); }
  1125.  
  1126.   template<typename _Sp>
  1127.     struct _Sp_less : public binary_function<_Sp, _Sp, bool>
  1128.     {
  1129.       bool
  1130.       operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
  1131.       {
  1132.         typedef typename _Sp::element_type element_type;
  1133.         return std::less<element_type*>()(__lhs.get(), __rhs.get());
  1134.       }
  1135.     };
  1136.  
  1137.   template<typename _Tp, _Lock_policy _Lp>
  1138.     struct less<__shared_ptr<_Tp, _Lp>>
  1139.     : public _Sp_less<__shared_ptr<_Tp, _Lp>>
  1140.     { };
  1141.  
  1142.   // 2.2.3.8 shared_ptr specialized algorithms.
  1143.   template<typename _Tp, _Lock_policy _Lp>
  1144.     inline void
  1145.     swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
  1146.     { __a.swap(__b); }
  1147.  
  1148.   // 2.2.3.9 shared_ptr casts
  1149.  
  1150.   // The seemingly equivalent code:
  1151.   // shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
  1152.   // will eventually result in undefined behaviour, attempting to
  1153.   // delete the same object twice.
  1154.   /// static_pointer_cast
  1155.   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  1156.     inline __shared_ptr<_Tp, _Lp>
  1157.     static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  1158.     { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
  1159.  
  1160.   // The seemingly equivalent code:
  1161.   // shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
  1162.   // will eventually result in undefined behaviour, attempting to
  1163.   // delete the same object twice.
  1164.   /// const_pointer_cast
  1165.   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  1166.     inline __shared_ptr<_Tp, _Lp>
  1167.     const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  1168.     { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
  1169.  
  1170.   // The seemingly equivalent code:
  1171.   // shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
  1172.   // will eventually result in undefined behaviour, attempting to
  1173.   // delete the same object twice.
  1174.   /// dynamic_pointer_cast
  1175.   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
  1176.     inline __shared_ptr<_Tp, _Lp>
  1177.     dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  1178.     {
  1179.       if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
  1180.         return __shared_ptr<_Tp, _Lp>(__r, __p);
  1181.       return __shared_ptr<_Tp, _Lp>();
  1182.     }
  1183.  
  1184.  
  1185.   template<typename _Tp, _Lock_policy _Lp>
  1186.     class __weak_ptr
  1187.     {
  1188.     public:
  1189.       typedef _Tp element_type;
  1190.  
  1191.       constexpr __weak_ptr() noexcept
  1192.       : _M_ptr(0), _M_refcount()
  1193.       { }
  1194.  
  1195.       __weak_ptr(const __weak_ptr&) noexcept = default;
  1196.       __weak_ptr& operator=(const __weak_ptr&) noexcept = default;
  1197.       ~__weak_ptr() = default;
  1198.  
  1199.       // The "obvious" converting constructor implementation:
  1200.       //
  1201.       //  template<typename _Tp1>
  1202.       //    __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
  1203.       //    : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
  1204.       //    { }
  1205.       //
  1206.       // has a serious problem.
  1207.       //
  1208.       //  __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
  1209.       //  conversion may require access to *__r._M_ptr (virtual inheritance).
  1210.       //
  1211.       // It is not possible to avoid spurious access violations since
  1212.       // in multithreaded programs __r._M_ptr may be invalidated at any point.
  1213.       template<typename _Tp1, typename = typename
  1214.                std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
  1215.         __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
  1216.         : _M_refcount(__r._M_refcount)
  1217.         { _M_ptr = __r.lock().get(); }
  1218.  
  1219.       template<typename _Tp1, typename = typename
  1220.                std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
  1221.         __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  1222.         : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
  1223.         { }
  1224.  
  1225.       template<typename _Tp1>
  1226.         __weak_ptr&
  1227.         operator=(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
  1228.         {
  1229.           _M_ptr = __r.lock().get();
  1230.           _M_refcount = __r._M_refcount;
  1231.           return *this;
  1232.         }
  1233.  
  1234.       template<typename _Tp1>
  1235.         __weak_ptr&
  1236.         operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
  1237.         {
  1238.           _M_ptr = __r._M_ptr;
  1239.           _M_refcount = __r._M_refcount;
  1240.           return *this;
  1241.         }
  1242.  
  1243.       __shared_ptr<_Tp, _Lp>
  1244.       lock() const noexcept
  1245.       {
  1246. #ifdef __GTHREADS
  1247.         // Optimization: avoid throw overhead.
  1248.         if (expired())
  1249.           return __shared_ptr<element_type, _Lp>();
  1250.  
  1251.         __try
  1252.           {
  1253.             return __shared_ptr<element_type, _Lp>(*this);
  1254.           }
  1255.         __catch(const bad_weak_ptr&)
  1256.           {
  1257.             // Q: How can we get here?
  1258.             // A: Another thread may have invalidated r after the
  1259.             //    use_count test above.
  1260.             return __shared_ptr<element_type, _Lp>();
  1261.           }
  1262.  
  1263. #else
  1264.         // Optimization: avoid try/catch overhead when single threaded.
  1265.         return expired() ? __shared_ptr<element_type, _Lp>()
  1266.                          : __shared_ptr<element_type, _Lp>(*this);
  1267.  
  1268. #endif
  1269.       } // XXX MT
  1270.  
  1271.       long
  1272.       use_count() const noexcept
  1273.       { return _M_refcount._M_get_use_count(); }
  1274.  
  1275.       bool
  1276.       expired() const noexcept
  1277.       { return _M_refcount._M_get_use_count() == 0; }
  1278.  
  1279.       template<typename _Tp1>
  1280.         bool
  1281.         owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
  1282.         { return _M_refcount._M_less(__rhs._M_refcount); }
  1283.  
  1284.       template<typename _Tp1>
  1285.         bool
  1286.         owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
  1287.         { return _M_refcount._M_less(__rhs._M_refcount); }
  1288.  
  1289.       void
  1290.       reset() noexcept
  1291.       { __weak_ptr().swap(*this); }
  1292.  
  1293.       void
  1294.       swap(__weak_ptr& __s) noexcept
  1295.       {
  1296.         std::swap(_M_ptr, __s._M_ptr);
  1297.         _M_refcount._M_swap(__s._M_refcount);
  1298.       }
  1299.  
  1300.     private:
  1301.       // Used by __enable_shared_from_this.
  1302.       void
  1303.       _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
  1304.       {
  1305.         _M_ptr = __ptr;
  1306.         _M_refcount = __refcount;
  1307.       }
  1308.  
  1309.       template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
  1310.       template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
  1311.       friend class __enable_shared_from_this<_Tp, _Lp>;
  1312.       friend class enable_shared_from_this<_Tp>;
  1313.  
  1314.       _Tp*               _M_ptr;         // Contained pointer.
  1315.       __weak_count<_Lp>  _M_refcount;    // Reference counter.
  1316.     };
  1317.  
  1318.   // 20.7.2.3.6 weak_ptr specialized algorithms.
  1319.   template<typename _Tp, _Lock_policy _Lp>
  1320.     inline void
  1321.     swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
  1322.     { __a.swap(__b); }
  1323.  
  1324.   template<typename _Tp, typename _Tp1>
  1325.     struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
  1326.     {
  1327.       bool
  1328.       operator()(const _Tp& __lhs, const _Tp& __rhs) const
  1329.       { return __lhs.owner_before(__rhs); }
  1330.  
  1331.       bool
  1332.       operator()(const _Tp& __lhs, const _Tp1& __rhs) const
  1333.       { return __lhs.owner_before(__rhs); }
  1334.  
  1335.       bool
  1336.       operator()(const _Tp1& __lhs, const _Tp& __rhs) const
  1337.       { return __lhs.owner_before(__rhs); }
  1338.     };
  1339.  
  1340.   template<typename _Tp, _Lock_policy _Lp>
  1341.     struct owner_less<__shared_ptr<_Tp, _Lp>>
  1342.     : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
  1343.     { };
  1344.  
  1345.   template<typename _Tp, _Lock_policy _Lp>
  1346.     struct owner_less<__weak_ptr<_Tp, _Lp>>
  1347.     : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
  1348.     { };
  1349.  
  1350.  
  1351.   template<typename _Tp, _Lock_policy _Lp>
  1352.     class __enable_shared_from_this
  1353.     {
  1354.     protected:
  1355.       constexpr __enable_shared_from_this() noexcept { }
  1356.  
  1357.       __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }
  1358.  
  1359.       __enable_shared_from_this&
  1360.       operator=(const __enable_shared_from_this&) noexcept
  1361.       { return *this; }
  1362.  
  1363.       ~__enable_shared_from_this() { }
  1364.  
  1365.     public:
  1366.       __shared_ptr<_Tp, _Lp>
  1367.       shared_from_this()
  1368.       { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
  1369.  
  1370.       __shared_ptr<const _Tp, _Lp>
  1371.       shared_from_this() const
  1372.       { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
  1373.  
  1374.     private:
  1375.       template<typename _Tp1>
  1376.         void
  1377.         _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
  1378.         { _M_weak_this._M_assign(__p, __n); }
  1379.  
  1380.       template<typename _Tp1>
  1381.         friend void
  1382.         __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
  1383.                                          const __enable_shared_from_this* __pe,
  1384.                                          const _Tp1* __px) noexcept
  1385.         {
  1386.           if (__pe != 0)
  1387.             __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
  1388.         }
  1389.  
  1390.       mutable __weak_ptr<_Tp, _Lp>  _M_weak_this;
  1391.     };
  1392.  
  1393.  
  1394.   template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
  1395.     inline __shared_ptr<_Tp, _Lp>
  1396.     __allocate_shared(const _Alloc& __a, _Args&&... __args)
  1397.     {
  1398.       return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
  1399.                                     std::forward<_Args>(__args)...);
  1400.     }
  1401.  
  1402.   template<typename _Tp, _Lock_policy _Lp, typename... _Args>
  1403.     inline __shared_ptr<_Tp, _Lp>
  1404.     __make_shared(_Args&&... __args)
  1405.     {
  1406.       typedef typename std::remove_const<_Tp>::type _Tp_nc;
  1407.       return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
  1408.                                               std::forward<_Args>(__args)...);
  1409.     }
  1410.  
  1411.   /// std::hash specialization for __shared_ptr.
  1412.   template<typename _Tp, _Lock_policy _Lp>
  1413.     struct hash<__shared_ptr<_Tp, _Lp>>
  1414.     : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
  1415.     {
  1416.       size_t
  1417.       operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
  1418.       { return std::hash<_Tp*>()(__s.get()); }
  1419.     };
  1420.  
  1421. _GLIBCXX_END_NAMESPACE_VERSION
  1422. } // namespace
  1423.  
  1424. #endif // _SHARED_PTR_BASE_H
  1425.