diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 353b2b6f7ba..b10764cbe47 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,7 @@ +2006-09-22 Paolo Carlini + + * include/tr1/boost_shared_ptr.h: Trivial formatting fixes. + 2006-09-21 Benjamin Kosnik * include/ext/type_traits.h (__numeric_traits_integer): New. diff --git a/libstdc++-v3/include/tr1/boost_shared_ptr.h b/libstdc++-v3/include/tr1/boost_shared_ptr.h index bc8028d08c7..03632075e46 100644 --- a/libstdc++-v3/include/tr1/boost_shared_ptr.h +++ b/libstdc++-v3/include/tr1/boost_shared_ptr.h @@ -58,1009 +58,1020 @@ namespace std { _GLIBCXX_BEGIN_NAMESPACE(tr1) -class bad_weak_ptr : public std::exception -{ -public: - virtual char const* - what() const throw() { return "tr1::bad_weak_ptr"; } -}; + class bad_weak_ptr : public std::exception + { + public: + virtual char const* + what() const throw() + { return "tr1::bad_weak_ptr"; } + }; // Substitute for bad_weak_ptr object in the case of -fno-exceptions. -inline void -__throw_bad_weak_ptr() -{ + inline void + __throw_bad_weak_ptr() + { #if __EXCEPTIONS - throw bad_weak_ptr(); + throw bad_weak_ptr(); #else - std::abort(); + std::abort(); #endif -} - -using __gnu_cxx::_Lock_policy; -using __gnu_cxx::__default_lock_policy; -using __gnu_cxx::_S_single; -using __gnu_cxx::_S_mutex; -using __gnu_cxx::_S_atomic; - -template - struct _Sp_deleter - { - typedef void result_type; - typedef _Tp* argument_type; - - void - operator()(_Tp* p) const - { delete p; } - }; - -// Empty helper class except when the template argument is _S_mutex. -template<_Lock_policy _Lp> - class _Mutex_base - { }; - -template<> - class _Mutex_base<_S_mutex> : public __gnu_cxx::__mutex - { }; - - -template<_Lock_policy _Lp = __default_lock_policy> - class _Sp_counted_base : public _Mutex_base<_Lp> - { - public: - _Sp_counted_base() : _M_use_count(1), _M_weak_count(1) { } - - virtual - ~_Sp_counted_base() // nothrow - { } - - // Called when _M_use_count drops to zero, to release the resources - // managed by *this. - virtual void - dispose() = 0; // nothrow - - // Called when _M_weak_count drops to zero. - virtual void - destroy() // nothrow - { delete this; } - - virtual void* - get_deleter(const std::type_info&) = 0; - - void - add_ref_copy() - { __gnu_cxx::__atomic_add(&_M_use_count, 1); } - - void - add_ref_lock(); - - void - release() // nothrow - { - if (__gnu_cxx::__exchange_and_add(&_M_use_count, -1) == 1) - { - dispose(); - #ifdef __GTHREADS - _GLIBCXX_READ_MEM_BARRIER; - _GLIBCXX_WRITE_MEM_BARRIER; - #endif - if (__gnu_cxx::__exchange_and_add(&_M_weak_count, -1) == 1) - destroy(); - } - } - - void - weak_add_ref() // nothrow - { __gnu_cxx::__atomic_add(&_M_weak_count, 1); } - - void - weak_release() // nothrow - { - if (__gnu_cxx::__exchange_and_add(&_M_weak_count, -1) == 1) - { -#ifdef __GTHREADS - _GLIBCXX_READ_MEM_BARRIER; - _GLIBCXX_WRITE_MEM_BARRIER; -#endif - destroy(); - } - } - - long - use_count() const // nothrow - { return _M_use_count; } // XXX is this MT safe? - - private: - _Sp_counted_base(_Sp_counted_base const&); - _Sp_counted_base& operator=(_Sp_counted_base const&); - - _Atomic_word _M_use_count; // #shared - _Atomic_word _M_weak_count; // #weak + (#shared != 0) - }; - -template<> - inline void - _Sp_counted_base<_S_single>::add_ref_lock() - { - if (__gnu_cxx::__exchange_and_add(&_M_use_count, 1) == 0) - { - _M_use_count = 0; - __throw_bad_weak_ptr(); - } - } - -#ifdef __GTHREADS -template<> - inline void - _Sp_counted_base<_S_mutex>::add_ref_lock() - { - __gnu_cxx::__scoped_lock sentry(*this); - if (__gnu_cxx::__exchange_and_add(&_M_use_count, 1) == 0) - { - _M_use_count = 0; - __throw_bad_weak_ptr(); - } - } -#endif - -template<> - inline void - _Sp_counted_base<_S_atomic>::add_ref_lock() - { - // Perform lock-free add-if-not-zero operation. - _Atomic_word __count; - do - { - __count = _M_use_count; - if (__count == 0) - __throw_bad_weak_ptr(); - - // Replace the current counter value with the old value + 1, as - // long as it's not changed meanwhile. - } - while (!__sync_bool_compare_and_swap(&_M_use_count, __count, __count + 1)); } -template - class _Sp_counted_base_impl : public _Sp_counted_base<_Lp> - { - public: - /** - * @brief - * @pre d(p) must not throw. - */ - _Sp_counted_base_impl(_Ptr __p, _Deleter __d) - : _M_ptr(__p), _M_del(__d) { } - - virtual void - dispose() // nothrow - { _M_del(_M_ptr); } - - virtual void* - get_deleter(const std::type_info& __ti) - { return __ti == typeid(_Deleter) ? &_M_del : 0; } - - private: - _Sp_counted_base_impl(const _Sp_counted_base_impl&); - _Sp_counted_base_impl& operator=(const _Sp_counted_base_impl&); - - _Ptr _M_ptr; // copy constructor must not throw - _Deleter _M_del; // copy constructor must not throw - }; + using __gnu_cxx::_Lock_policy; + using __gnu_cxx::__default_lock_policy; + using __gnu_cxx::_S_single; + using __gnu_cxx::_S_mutex; + using __gnu_cxx::_S_atomic; -template<_Lock_policy _Lp = __default_lock_policy> - class weak_count; - -template<_Lock_policy _Lp = __default_lock_policy> - class shared_count - { - private: - _Sp_counted_base<_Lp>* _M_pi; - - friend class weak_count<_Lp>; - - public: - shared_count() : _M_pi(0) // nothrow - { } - - template - shared_count(_Ptr __p, _Deleter __d) : _M_pi(0) - { - try - { - _M_pi = new _Sp_counted_base_impl<_Ptr, _Deleter, _Lp>(__p, __d); - } - catch(...) - { - __d(__p); // Call _Deleter on __p. - __throw_exception_again; - } - } - - // Special case for auto_ptr<_Tp> to provide the strong guarantee. - template - explicit shared_count(std::auto_ptr<_Tp>& __r) - : _M_pi(new _Sp_counted_base_impl<_Tp*, - _Sp_deleter<_Tp>, _Lp >(__r.get(), _Sp_deleter<_Tp>())) - { __r.release(); } - - // Throw bad_weak_ptr when __r.use_count() == 0. - explicit shared_count(const weak_count<_Lp>& __r); - - ~shared_count() // nothrow + template + struct _Sp_deleter { - if (_M_pi != 0) - _M_pi->release(); - } - - shared_count(const shared_count& __r) - : _M_pi(__r._M_pi) // nothrow - { - if (_M_pi != 0) - _M_pi->add_ref_copy(); - } - - shared_count& - operator=(const shared_count& __r) // nothrow - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - if (__tmp != _M_pi) - { - if (__tmp != 0) - __tmp->add_ref_copy(); - if (_M_pi != 0) - _M_pi->release(); - _M_pi = __tmp; - } - return *this; - } - - void swap(shared_count& __r) // nothrow - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - __r._M_pi = _M_pi; - _M_pi = __tmp; - } - - long - use_count() const // nothrow - { return _M_pi != 0 ? _M_pi->use_count() : 0; } - - bool - unique() const // nothrow - { return this->use_count() == 1; } - - friend inline bool - operator==(const shared_count& __a, const shared_count& __b) - { return __a._M_pi == __b._M_pi; } - - friend inline bool - operator<(const shared_count& __a, const shared_count& __b) - { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); } - - void* - get_deleter(const std::type_info& __ti) const - { return _M_pi ? _M_pi->get_deleter(__ti) : 0; } - }; + typedef void result_type; + typedef _Tp* argument_type; -template<_Lock_policy _Lp> - class weak_count - { - private: - _Sp_counted_base<_Lp>* _M_pi; - - friend class shared_count<_Lp>; - - public: - weak_count() - : _M_pi(0) // nothrow - { } - - weak_count(const shared_count<_Lp>& __r) - : _M_pi(__r._M_pi) // nothrow - { - if (_M_pi != 0) - _M_pi->weak_add_ref(); - } - - weak_count(const weak_count<_Lp>& __r) - : _M_pi(__r._M_pi) // nothrow - { - if (_M_pi != 0) - _M_pi->weak_add_ref(); - } - - ~weak_count() // nothrow - { - if (_M_pi != 0) - _M_pi->weak_release(); - } - - weak_count<_Lp>& - operator=(const shared_count<_Lp>& __r) // nothrow - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - if (__tmp != 0) - __tmp->weak_add_ref(); - if (_M_pi != 0) - _M_pi->weak_release(); - _M_pi = __tmp; - return *this; - } - - weak_count<_Lp>& - operator=(const weak_count<_Lp>& __r) // nothrow - { - _Sp_counted_base<_Lp> * __tmp = __r._M_pi; - if (__tmp != 0) - __tmp->weak_add_ref(); - if (_M_pi != 0) - _M_pi->weak_release(); - _M_pi = __tmp; - return *this; - } - - void - swap(weak_count<_Lp>& __r) // nothrow - { - _Sp_counted_base<_Lp> * __tmp = __r._M_pi; - __r._M_pi = _M_pi; - _M_pi = __tmp; - } - - long - use_count() const // nothrow - { return _M_pi != 0 ? _M_pi->use_count() : 0; } - - friend inline bool - operator==(const weak_count<_Lp>& __a, const weak_count<_Lp>& __b) - { return __a._M_pi == __b._M_pi; } - - friend inline bool - operator<(const weak_count<_Lp>& __a, const weak_count<_Lp>& __b) - { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); } - }; - -template<_Lock_policy _Lp> - inline - shared_count<_Lp>::shared_count(const weak_count<_Lp>& __r) - : _M_pi(__r._M_pi) - { - if (_M_pi != 0) - _M_pi->add_ref_lock(); - else - __throw_bad_weak_ptr(); - } - - -// Forward decls. -template - class __shared_ptr; - -template - class __weak_ptr; - -template - class __enable_shared_from_this; - -struct __static_cast_tag { }; -struct __const_cast_tag { }; -struct __dynamic_cast_tag { }; -struct __polymorphic_cast_tag { }; - -template - struct shared_ptr_traits - { typedef _Tp& reference; }; - -template<> - struct shared_ptr_traits - { typedef void reference; }; - -template<> - struct shared_ptr_traits - { typedef void reference; }; - -template<> - struct shared_ptr_traits - { typedef void reference; }; - -template<> - struct shared_ptr_traits - { typedef void reference; }; - - -// Support for enable_shared_from_this. - -// Friend of __enable_shared_from_this. -template<_Lock_policy _Lp, typename _Tp1, typename _Tp2> - void - __enable_shared_from_this_helper(const shared_count<_Lp>&, - const __enable_shared_from_this<_Tp1, _Lp>*, - const _Tp2*); - -template<_Lock_policy _Lp> - inline void - __enable_shared_from_this_helper(const shared_count<_Lp>&, ...) - { } - - -/** - * @class shared_ptr - * - * A smart pointer with reference-counted copy semantics. - * The object pointed to is deleted when the last shared_ptr pointing to it - * is destroyed or reset. - */ -template - class __shared_ptr - { - typedef typename shared_ptr_traits<_Tp>::reference _Reference; - - public: - typedef _Tp element_type; - - /** @brief Construct an empty %__shared_ptr. - * @post use_count()==0 && get()==0 - */ - __shared_ptr() - : _M_ptr(0), _M_refcount() // never throws - { } - - /** @brief Construct a %__shared_ptr that owns the pointer @a p. - * @param p A pointer that is convertible to element_type*. - * @post use_count() == 1 && get() == p - * @throw std::bad_alloc, in which case @c delete @a p is called. - */ - template - explicit __shared_ptr(_Tp1* __p) - : _M_ptr(__p), _M_refcount(__p, _Sp_deleter<_Tp1>()) - { - __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) - // __glibcxx_function_requires(_CompleteConcept<_Tp1*>) - __enable_shared_from_this_helper( _M_refcount, __p, __p ); - } - - // - // Requirements: D's copy constructor and destructor must not throw - // - // __shared_ptr will release p by calling d(p) - // - /** @brief Construct a %__shared_ptr that owns the pointer @a p - * and the deleter @a d. - * @param p A pointer. - * @param d A deleter. - * @post use_count() == 1 && get() == p - * @throw std::bad_alloc, in which case @a d(p) is called. - */ - template - __shared_ptr(_Tp1* __p, _Deleter __d) - : _M_ptr(__p), _M_refcount(__p, __d) - { - __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) - // TODO requires D is CopyConstructible and d(p) well-formed - __enable_shared_from_this_helper( _M_refcount, __p, __p ); - } - - // generated copy constructor, assignment, destructor are fine. - - /** @brief If @a r is empty, constructs an empty %__shared_ptr; otherwise - * construct a %__shared_ptr that shares ownership with @a r. - * @param r A %__shared_ptr. - * @post get() == r.get() && use_count() == r.use_count() - * @throw std::bad_alloc, in which case - */ - template - __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) - : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws - { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } - - /** @brief Constructs a %__shared_ptr that shares ownership with @a r - * and stores a copy of the pointer stored in @a r. - * @param r A weak_ptr. - * @post use_count() == r.use_count() - * @throw bad_weak_ptr when r.expired(), - * in which case the constructor has no effect. - */ - template - explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r) - : _M_refcount(__r._M_refcount) // may throw - { - __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) - // It is now safe to copy r__._M_ptr, as _M_refcount(__r._M_refcount) - // did not throw. - _M_ptr = __r._M_ptr; - } - - /** - * @post use_count() == 1 and r.get() == 0 - */ - template - explicit __shared_ptr(std::auto_ptr<_Tp1>& __r) - : _M_ptr(__r.get()), _M_refcount() - { - // TODO requires r.release() convertible to _Tp*, Tp1 is complete, - // delete r.release() well-formed - _Tp1 * __tmp = __r.get(); - _M_refcount = shared_count<_Lp>(__r); - __enable_shared_from_this_helper( _M_refcount, __tmp, __tmp ); - } - - template - __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __static_cast_tag) - : _M_ptr(static_cast(__r._M_ptr)), - _M_refcount(__r._M_refcount) - { } - - template - __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __const_cast_tag) - : _M_ptr(const_cast(__r._M_ptr)), - _M_refcount(__r._M_refcount) - { } - - template - __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __dynamic_cast_tag) - : _M_ptr(dynamic_cast(__r._M_ptr)), - _M_refcount(__r._M_refcount) - { - if (_M_ptr == 0) // need to allocate new counter -- the cast failed - _M_refcount = shared_count<_Lp>(); - } - - template - __shared_ptr& - operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws - { - _M_ptr = __r._M_ptr; - _M_refcount = __r._M_refcount; // shared_count::op= doesn't throw - return *this; - } - - template - __shared_ptr& - operator=(std::auto_ptr<_Tp1>& __r) - { - __shared_ptr(__r).swap(*this); - return *this; - } - - void - reset() // never throws - { __shared_ptr().swap(*this); } - - template void - reset(_Tp1* __p) // _Tp1 must be complete. - { - // Catch self-reset errors. - _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr); - __shared_ptr(__p).swap(*this); - } + operator()(_Tp* p) const + { delete p; } + }; - template - void - reset(_Tp1 * __p, _Deleter __d) - { __shared_ptr(__p, __d).swap(*this); } + // Empty helper class except when the template argument is _S_mutex. + template<_Lock_policy _Lp> + class _Mutex_base + { }; - // Error to instantiate if _Tp is [cv-qual] void. - _Reference - operator*() const // never throws + template<> + class _Mutex_base<_S_mutex> : public __gnu_cxx::__mutex + { }; + + template<_Lock_policy _Lp = __default_lock_policy> + class _Sp_counted_base : public _Mutex_base<_Lp> { - _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); - return *_M_ptr; - } - - _Tp* - operator->() const // never throws - { - _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); - return _M_ptr; - } - - _Tp* - get() const // never throws - { return _M_ptr; } - - // Implicit conversion to "bool" - private: - typedef _Tp* __shared_ptr::*__unspecified_bool_type; - - public: - operator __unspecified_bool_type() const // never throws - { return _M_ptr == 0 ? 0 : &__shared_ptr::_M_ptr; } - - bool - unique() const // never throws - { return _M_refcount.unique(); } - - long - use_count() const // never throws - { return _M_refcount.use_count(); } - - void - swap(__shared_ptr<_Tp, _Lp>& __other) // never throws - { - std::swap(_M_ptr, __other._M_ptr); - _M_refcount.swap(__other._M_refcount); - } - - private: - void* - _M_get_deleter(const std::type_info& __ti) const - { return _M_refcount.get_deleter(__ti); } - - template - bool - _M_less(const __shared_ptr<_Tp1, _Lp1>& __rhs) const - { return _M_refcount < __rhs._M_refcount; } - - template friend class __shared_ptr; - template friend class __weak_ptr; - - template - friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&); - - // Friends injected into enclosing namespace and found by ADL: - template - friend inline bool - operator==(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) - { return __a.get() == __b.get(); } - - template - friend inline bool - operator!=(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) - { return __a.get() != __b.get(); } - - template - friend inline bool - operator<(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) - { return __a._M_less(__b); } - - _Tp* _M_ptr; // Contained pointer. - shared_count<_Lp> _M_refcount; // Reference counter. - }; - -// 2.2.3.8 shared_ptr specialized algorithms. -template - inline void - swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) - { __a.swap(__b); } - -// 2.2.3.9 shared_ptr casts -/** @warning The seemingly equivalent - * shared_ptr(static_cast(r.get())) - * will eventually result in undefined behaviour, - * attempting to delete the same object twice. - */ -template - __shared_ptr<_Tp, _Lp> - static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) - { return __shared_ptr<_Tp, _Lp>(__r, __static_cast_tag()); } - -/** @warning The seemingly equivalent - * shared_ptr(const_cast(r.get())) - * will eventually result in undefined behaviour, - * attempting to delete the same object twice. - */ -template - __shared_ptr<_Tp, _Lp> - const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) - { return __shared_ptr<_Tp, _Lp>(__r, __const_cast_tag()); } - -/** @warning The seemingly equivalent - * shared_ptr(dynamic_cast(r.get())) - * will eventually result in undefined behaviour, - * attempting to delete the same object twice. - */ -template - __shared_ptr<_Tp, _Lp> - dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) - { return __shared_ptr<_Tp, _Lp>(__r, __dynamic_cast_tag()); } - -// 2.2.3.7 shared_ptr I/O -template - std::basic_ostream<_Ch, _Tr>& - operator<<(std::basic_ostream<_Ch, _Tr>& __os, - const __shared_ptr<_Tp, _Lp>& __p) - { - __os << __p.get(); - return __os; - } - -// 2.2.3.10 shared_ptr get_deleter (experimental) -template - inline _Del* - get_deleter(const __shared_ptr<_Tp, _Lp>& __p) - { return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); } - - -template - class __weak_ptr - { - public: - typedef _Tp element_type; - - __weak_ptr() : _M_ptr(0), _M_refcount() // never throws - { } - - // Generated copy constructor, assignment, destructor are fine. - - // The "obvious" converting constructor implementation: - // - // template - // __weak_ptr(__weak_ptr const & r) - // : _M_ptr(r._M_ptr), _M_refcount(r._M_refcount) // never throws - // { } - // - // has a serious problem. - // - // r._M_ptr may already have been invalidated. The _M_ptr(r._M_ptr) - // conversion may require access to *r._M_ptr (virtual inheritance). - // - // It is not possible to avoid spurious access violations since - // in multithreaded programs r._M_ptr may be invalidated at any point. - template - __weak_ptr(const __weak_ptr<_Tp1, _Lp>& r) - : _M_refcount(r._M_refcount) // never throws - { - __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) - _M_ptr = r.lock().get(); - } - - template - __weak_ptr(const __shared_ptr<_Tp1, _Lp>& r) - : _M_ptr(r._M_ptr), _M_refcount(r._M_refcount) // never throws - { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } - - template - __weak_ptr& - operator=(const __weak_ptr<_Tp1, _Lp>& r) // never throws - { - _M_ptr = r.lock().get(); - _M_refcount = r._M_refcount; - return *this; - } - - template - __weak_ptr& - operator=(const __shared_ptr<_Tp1, _Lp>& r) // never throws - { - _M_ptr = r._M_ptr; - _M_refcount = r._M_refcount; - return *this; - } - - __shared_ptr<_Tp, _Lp> - lock() const // never throws - { -#ifdef __GTHREADS - // Optimization: avoid throw overhead. - if (expired()) - return __shared_ptr(); + public: + _Sp_counted_base() : _M_use_count(1), _M_weak_count(1) { } - try + virtual + ~_Sp_counted_base() // nothrow + { } + + // Called when _M_use_count drops to zero, to release the resources + // managed by *this. + virtual void + dispose() = 0; // nothrow + + // Called when _M_weak_count drops to zero. + virtual void + destroy() // nothrow + { delete this; } + + virtual void* + get_deleter(const std::type_info&) = 0; + + void + add_ref_copy() + { __gnu_cxx::__atomic_add(&_M_use_count, 1); } + + void + add_ref_lock(); + + void + release() // nothrow + { + if (__gnu_cxx::__exchange_and_add(&_M_use_count, -1) == 1) + { + dispose(); +#ifdef __GTHREADS + _GLIBCXX_READ_MEM_BARRIER; + _GLIBCXX_WRITE_MEM_BARRIER; +#endif + if (__gnu_cxx::__exchange_and_add(&_M_weak_count, -1) == 1) + destroy(); + } + } + + void + weak_add_ref() // nothrow + { __gnu_cxx::__atomic_add(&_M_weak_count, 1); } + + void + weak_release() // nothrow + { + if (__gnu_cxx::__exchange_and_add(&_M_weak_count, -1) == 1) + { +#ifdef __GTHREADS + _GLIBCXX_READ_MEM_BARRIER; + _GLIBCXX_WRITE_MEM_BARRIER; +#endif + destroy(); + } + } + + long + use_count() const // nothrow + { return _M_use_count; } // XXX is this MT safe? + + private: + _Sp_counted_base(_Sp_counted_base const&); + _Sp_counted_base& operator=(_Sp_counted_base const&); + + _Atomic_word _M_use_count; // #shared + _Atomic_word _M_weak_count; // #weak + (#shared != 0) + }; + + template<> + inline void + _Sp_counted_base<_S_single>::add_ref_lock() + { + if (__gnu_cxx::__exchange_and_add(&_M_use_count, 1) == 0) { - return __shared_ptr(*this); + _M_use_count = 0; + __throw_bad_weak_ptr(); } - catch (const bad_weak_ptr&) + } + +#ifdef __GTHREADS + template<> + inline void + _Sp_counted_base<_S_mutex>::add_ref_lock() + { + __gnu_cxx::__scoped_lock sentry(*this); + if (__gnu_cxx::__exchange_and_add(&_M_use_count, 1) == 0) { - // Q: How can we get here? - // A: Another thread may have invalidated r after the - // use_count test above. - return __shared_ptr(); + _M_use_count = 0; + __throw_bad_weak_ptr(); + } + } +#endif + + template<> + inline void + _Sp_counted_base<_S_atomic>::add_ref_lock() + { + // Perform lock-free add-if-not-zero operation. + _Atomic_word __count; + do + { + __count = _M_use_count; + if (__count == 0) + __throw_bad_weak_ptr(); + + // Replace the current counter value with the old value + 1, as + // long as it's not changed meanwhile. + } + while (!__sync_bool_compare_and_swap(&_M_use_count, __count, + __count + 1)); + } + + template + class _Sp_counted_base_impl : public _Sp_counted_base<_Lp> + { + public: + /** + * @brief + * @pre d(p) must not throw. + */ + _Sp_counted_base_impl(_Ptr __p, _Deleter __d) + : _M_ptr(__p), _M_del(__d) { } + + virtual void + dispose() // nothrow + { _M_del(_M_ptr); } + + virtual void* + get_deleter(const std::type_info& __ti) + { return __ti == typeid(_Deleter) ? &_M_del : 0; } + + private: + _Sp_counted_base_impl(const _Sp_counted_base_impl&); + _Sp_counted_base_impl& operator=(const _Sp_counted_base_impl&); + + _Ptr _M_ptr; // copy constructor must not throw + _Deleter _M_del; // copy constructor must not throw + }; + + template<_Lock_policy _Lp = __default_lock_policy> + class weak_count; + + template<_Lock_policy _Lp = __default_lock_policy> + class shared_count + { + private: + _Sp_counted_base<_Lp>* _M_pi; + + friend class weak_count<_Lp>; + + public: + shared_count() : _M_pi(0) // nothrow + { } + + template + shared_count(_Ptr __p, _Deleter __d) : _M_pi(0) + { + try + { + _M_pi = new _Sp_counted_base_impl<_Ptr, _Deleter, _Lp>(__p, __d); + } + catch(...) + { + __d(__p); // Call _Deleter on __p. + __throw_exception_again; + } + } + + // Special case for auto_ptr<_Tp> to provide the strong guarantee. + template + explicit + shared_count(std::auto_ptr<_Tp>& __r) + : _M_pi(new _Sp_counted_base_impl<_Tp*, + _Sp_deleter<_Tp>, _Lp >(__r.get(), _Sp_deleter<_Tp>())) + { __r.release(); } + + // Throw bad_weak_ptr when __r.use_count() == 0. + explicit shared_count(const weak_count<_Lp>& __r); + + ~shared_count() // nothrow + { + if (_M_pi != 0) + _M_pi->release(); + } + + shared_count(const shared_count& __r) + : _M_pi(__r._M_pi) // nothrow + { + if (_M_pi != 0) + _M_pi->add_ref_copy(); + } + + shared_count& + operator=(const shared_count& __r) // nothrow + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + if (__tmp != _M_pi) + { + if (__tmp != 0) + __tmp->add_ref_copy(); + if (_M_pi != 0) + _M_pi->release(); + _M_pi = __tmp; + } + return *this; + } + + void + swap(shared_count& __r) // nothrow + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + __r._M_pi = _M_pi; + _M_pi = __tmp; + } + + long + use_count() const // nothrow + { return _M_pi != 0 ? _M_pi->use_count() : 0; } + + bool + unique() const // nothrow + { return this->use_count() == 1; } + + friend inline bool + operator==(const shared_count& __a, const shared_count& __b) + { return __a._M_pi == __b._M_pi; } + + friend inline bool + operator<(const shared_count& __a, const shared_count& __b) + { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); } + + void* + get_deleter(const std::type_info& __ti) const + { return _M_pi ? _M_pi->get_deleter(__ti) : 0; } + }; + + template<_Lock_policy _Lp> + class weak_count + { + private: + _Sp_counted_base<_Lp>* _M_pi; + + friend class shared_count<_Lp>; + + public: + weak_count() + : _M_pi(0) // nothrow + { } + + weak_count(const shared_count<_Lp>& __r) + : _M_pi(__r._M_pi) // nothrow + { + if (_M_pi != 0) + _M_pi->weak_add_ref(); + } + + weak_count(const weak_count<_Lp>& __r) + : _M_pi(__r._M_pi) // nothrow + { + if (_M_pi != 0) + _M_pi->weak_add_ref(); + } + + ~weak_count() // nothrow + { + if (_M_pi != 0) + _M_pi->weak_release(); + } + + weak_count<_Lp>& + operator=(const shared_count<_Lp>& __r) // nothrow + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + if (__tmp != 0) + __tmp->weak_add_ref(); + if (_M_pi != 0) + _M_pi->weak_release(); + _M_pi = __tmp; + return *this; + } + + weak_count<_Lp>& + operator=(const weak_count<_Lp>& __r) // nothrow + { + _Sp_counted_base<_Lp> * __tmp = __r._M_pi; + if (__tmp != 0) + __tmp->weak_add_ref(); + if (_M_pi != 0) + _M_pi->weak_release(); + _M_pi = __tmp; + return *this; + } + + void + swap(weak_count<_Lp>& __r) // nothrow + { + _Sp_counted_base<_Lp> * __tmp = __r._M_pi; + __r._M_pi = _M_pi; + _M_pi = __tmp; + } + + long + use_count() const // nothrow + { return _M_pi != 0 ? _M_pi->use_count() : 0; } + + friend inline bool + operator==(const weak_count<_Lp>& __a, const weak_count<_Lp>& __b) + { return __a._M_pi == __b._M_pi; } + + friend inline bool + operator<(const weak_count<_Lp>& __a, const weak_count<_Lp>& __b) + { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); } + }; + + template<_Lock_policy _Lp> + inline + shared_count<_Lp>:: + shared_count(const weak_count<_Lp>& __r) + : _M_pi(__r._M_pi) + { + if (_M_pi != 0) + _M_pi->add_ref_lock(); + else + __throw_bad_weak_ptr(); + } + + + // Forward decls. + template + class __shared_ptr; + + template + class __weak_ptr; + + template + class __enable_shared_from_this; + + struct __static_cast_tag { }; + struct __const_cast_tag { }; + struct __dynamic_cast_tag { }; + struct __polymorphic_cast_tag { }; + + template + struct __shared_ptr_reference + { typedef _Tp& __type; }; + + template<> + struct __shared_ptr_reference + { typedef void __type; }; + + template<> + struct __shared_ptr_reference + { typedef void __type; }; + + template<> + struct __shared_ptr_reference + { typedef void __type; }; + + template<> + struct __shared_ptr_reference + { typedef void __type; }; + + + // Support for enable_shared_from_this. + + // Friend of __enable_shared_from_this. + template<_Lock_policy _Lp, typename _Tp1, typename _Tp2> + void + __enable_shared_from_this_helper(const shared_count<_Lp>&, + const __enable_shared_from_this<_Tp1, + _Lp>*, const _Tp2*); + + template<_Lock_policy _Lp> + inline void + __enable_shared_from_this_helper(const shared_count<_Lp>&, ...) + { } + + + /** + * @class shared_ptr + * + * A smart pointer with reference-counted copy semantics. + * The object pointed to is deleted when the last shared_ptr pointing to + * it is destroyed or reset. + */ + template + class __shared_ptr + { + typedef typename __shared_ptr_reference<_Tp>::__type _Reference; + + public: + typedef _Tp element_type; + + /** @brief Construct an empty %__shared_ptr. + * @post use_count()==0 && get()==0 + */ + __shared_ptr() + : _M_ptr(0), _M_refcount() // never throws + { } + + /** @brief Construct a %__shared_ptr that owns the pointer @a p. + * @param p A pointer that is convertible to element_type*. + * @post use_count() == 1 && get() == p + * @throw std::bad_alloc, in which case @c delete @a p is called. + */ + template + explicit + __shared_ptr(_Tp1* __p) + : _M_ptr(__p), _M_refcount(__p, _Sp_deleter<_Tp1>()) + { + __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) + // __glibcxx_function_requires(_CompleteConcept<_Tp1*>) + __enable_shared_from_this_helper( _M_refcount, __p, __p ); } + // + // Requirements: D's copy constructor and destructor must not throw + // + // __shared_ptr will release p by calling d(p) + // + /** @brief Construct a %__shared_ptr that owns the pointer @a p + * and the deleter @a d. + * @param p A pointer. + * @param d A deleter. + * @post use_count() == 1 && get() == p + * @throw std::bad_alloc, in which case @a d(p) is called. + */ + template + __shared_ptr(_Tp1* __p, _Deleter __d) + : _M_ptr(__p), _M_refcount(__p, __d) + { + __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) + // TODO requires D is CopyConstructible and d(p) well-formed + __enable_shared_from_this_helper( _M_refcount, __p, __p ); + } + + // generated copy constructor, assignment, destructor are fine. + + /** @brief If @a r is empty, constructs an empty %__shared_ptr; + * otherwise construct a %__shared_ptr that shares ownership + * with @a r. + * @param r A %__shared_ptr. + * @post get() == r.get() && use_count() == r.use_count() + * @throw std::bad_alloc, in which case + */ + template + __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) + : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws + { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } + + /** @brief Constructs a %__shared_ptr that shares ownership with @a r + * and stores a copy of the pointer stored in @a r. + * @param r A weak_ptr. + * @post use_count() == r.use_count() + * @throw bad_weak_ptr when r.expired(), + * in which case the constructor has no effect. + */ + template + explicit + __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r) + : _M_refcount(__r._M_refcount) // may throw + { + __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) + // It is now safe to copy r__._M_ptr, as _M_refcount(__r._M_refcount) + // did not throw. + _M_ptr = __r._M_ptr; + } + + /** + * @post use_count() == 1 and r.get() == 0 + */ + template + explicit + __shared_ptr(std::auto_ptr<_Tp1>& __r) + : _M_ptr(__r.get()), _M_refcount() + { + // TODO requires r.release() convertible to _Tp*, Tp1 is complete, + // delete r.release() well-formed + _Tp1 * __tmp = __r.get(); + _M_refcount = shared_count<_Lp>(__r); + __enable_shared_from_this_helper( _M_refcount, __tmp, __tmp ); + } + + template + __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __static_cast_tag) + : _M_ptr(static_cast(__r._M_ptr)), + _M_refcount(__r._M_refcount) + { } + + template + __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __const_cast_tag) + : _M_ptr(const_cast(__r._M_ptr)), + _M_refcount(__r._M_refcount) + { } + + template + __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __dynamic_cast_tag) + : _M_ptr(dynamic_cast(__r._M_ptr)), + _M_refcount(__r._M_refcount) + { + if (_M_ptr == 0) // need to allocate new counter -- the cast failed + _M_refcount = shared_count<_Lp>(); + } + + template + __shared_ptr& + operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws + { + _M_ptr = __r._M_ptr; + _M_refcount = __r._M_refcount; // shared_count::op= doesn't throw + return *this; + } + + template + __shared_ptr& + operator=(std::auto_ptr<_Tp1>& __r) + { + __shared_ptr(__r).swap(*this); + return *this; + } + + void + reset() // never throws + { __shared_ptr().swap(*this); } + + template + void + reset(_Tp1* __p) // _Tp1 must be complete. + { + // Catch self-reset errors. + _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr); + __shared_ptr(__p).swap(*this); + } + + template + void + reset(_Tp1 * __p, _Deleter __d) + { __shared_ptr(__p, __d).swap(*this); } + + // Error to instantiate if _Tp is [cv-qual] void. + _Reference + operator*() const // never throws + { + _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); + return *_M_ptr; + } + + _Tp* + operator->() const // never throws + { + _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); + return _M_ptr; + } + + _Tp* + get() const // never throws + { return _M_ptr; } + + // Implicit conversion to "bool" + private: + typedef _Tp* __shared_ptr::*__unspecified_bool_type; + + public: + operator __unspecified_bool_type() const // never throws + { return _M_ptr == 0 ? 0 : &__shared_ptr::_M_ptr; } + + bool + unique() const // never throws + { return _M_refcount.unique(); } + + long + use_count() const // never throws + { return _M_refcount.use_count(); } + + void + swap(__shared_ptr<_Tp, _Lp>& __other) // never throws + { + std::swap(_M_ptr, __other._M_ptr); + _M_refcount.swap(__other._M_refcount); + } + + private: + void* + _M_get_deleter(const std::type_info& __ti) const + { return _M_refcount.get_deleter(__ti); } + + template + bool + _M_less(const __shared_ptr<_Tp1, _Lp1>& __rhs) const + { return _M_refcount < __rhs._M_refcount; } + + template friend class __shared_ptr; + template friend class __weak_ptr; + + template + friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&); + + // Friends injected into enclosing namespace and found by ADL: + template + friend inline bool + operator==(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) + { return __a.get() == __b.get(); } + + template + friend inline bool + operator!=(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) + { return __a.get() != __b.get(); } + + template + friend inline bool + operator<(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) + { return __a._M_less(__b); } + + _Tp* _M_ptr; // Contained pointer. + shared_count<_Lp> _M_refcount; // Reference counter. + }; + + // 2.2.3.8 shared_ptr specialized algorithms. + template + inline void + swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) + { __a.swap(__b); } + + // 2.2.3.9 shared_ptr casts + /** @warning The seemingly equivalent + * shared_ptr(static_cast(r.get())) + * will eventually result in undefined behaviour, + * attempting to delete the same object twice. + */ + template + __shared_ptr<_Tp, _Lp> + static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) + { return __shared_ptr<_Tp, _Lp>(__r, __static_cast_tag()); } + + /** @warning The seemingly equivalent + * shared_ptr(const_cast(r.get())) + * will eventually result in undefined behaviour, + * attempting to delete the same object twice. + */ + template + __shared_ptr<_Tp, _Lp> + const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) + { return __shared_ptr<_Tp, _Lp>(__r, __const_cast_tag()); } + + /** @warning The seemingly equivalent + * shared_ptr(dynamic_cast(r.get())) + * will eventually result in undefined behaviour, + * attempting to delete the same object twice. + */ + template + __shared_ptr<_Tp, _Lp> + dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) + { return __shared_ptr<_Tp, _Lp>(__r, __dynamic_cast_tag()); } + + // 2.2.3.7 shared_ptr I/O + template + std::basic_ostream<_Ch, _Tr>& + operator<<(std::basic_ostream<_Ch, _Tr>& __os, + const __shared_ptr<_Tp, _Lp>& __p) + { + __os << __p.get(); + return __os; + } + + // 2.2.3.10 shared_ptr get_deleter (experimental) + template + inline _Del* + get_deleter(const __shared_ptr<_Tp, _Lp>& __p) + { return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); } + + + template + class __weak_ptr + { + public: + typedef _Tp element_type; + + __weak_ptr() : _M_ptr(0), _M_refcount() // never throws + { } + + // Generated copy constructor, assignment, destructor are fine. + + // The "obvious" converting constructor implementation: + // + // template + // __weak_ptr(__weak_ptr const & r) + // : _M_ptr(r._M_ptr), _M_refcount(r._M_refcount) // never throws + // { } + // + // has a serious problem. + // + // r._M_ptr may already have been invalidated. The _M_ptr(r._M_ptr) + // conversion may require access to *r._M_ptr (virtual inheritance). + // + // It is not possible to avoid spurious access violations since + // in multithreaded programs r._M_ptr may be invalidated at any point. + template + __weak_ptr(const __weak_ptr<_Tp1, _Lp>& r) + : _M_refcount(r._M_refcount) // never throws + { + __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) + _M_ptr = r.lock().get(); + } + + template + __weak_ptr(const __shared_ptr<_Tp1, _Lp>& r) + : _M_ptr(r._M_ptr), _M_refcount(r._M_refcount) // never throws + { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } + + template + __weak_ptr& + operator=(const __weak_ptr<_Tp1, _Lp>& r) // never throws + { + _M_ptr = r.lock().get(); + _M_refcount = r._M_refcount; + return *this; + } + + template + __weak_ptr& + operator=(const __shared_ptr<_Tp1, _Lp>& r) // never throws + { + _M_ptr = r._M_ptr; + _M_refcount = r._M_refcount; + return *this; + } + + __shared_ptr<_Tp, _Lp> + lock() const // never throws + { +#ifdef __GTHREADS + // Optimization: avoid throw overhead. + if (expired()) + return __shared_ptr(); + + try + { + return __shared_ptr(*this); + } + catch (const bad_weak_ptr&) + { + // Q: How can we get here? + // A: Another thread may have invalidated r after the + // use_count test above. + return __shared_ptr(); + } + #else - // Optimization: avoid try/catch overhead when single threaded. - return expired() ? __shared_ptr() - : __shared_ptr(*this); + // Optimization: avoid try/catch overhead when single threaded. + return expired() ? __shared_ptr() + : __shared_ptr(*this); #endif - } // XXX MT + } // XXX MT - long - use_count() const // never throws - { return _M_refcount.use_count(); } + long + use_count() const // never throws + { return _M_refcount.use_count(); } - bool - expired() const // never throws - { return _M_refcount.use_count() == 0; } - - void - reset() // never throws - { __weak_ptr().swap(*this); } - - void - swap(__weak_ptr& __s) // never throws - { - std::swap(_M_ptr, __s._M_ptr); - _M_refcount.swap(__s._M_refcount); - } - - private: - template bool - _M_less(const __weak_ptr<_Tp1, _Lp>& __rhs) const - { return _M_refcount < __rhs._M_refcount; } - - // Used by __enable_shared_from_this. - void - _M_assign(_Tp* __ptr, const shared_count<_Lp>& __refcount) - { - _M_ptr = __ptr; - _M_refcount = __refcount; - } - - // Friend injected into namespace and found by ADL. - template - friend inline bool - operator<(const __weak_ptr& __lhs, const __weak_ptr<_Tp1, _Lp>& __rhs) - { return __lhs._M_less(__rhs); } - - template friend class __weak_ptr; - template friend class __shared_ptr; - friend class __enable_shared_from_this<_Tp, _Lp>; - - _Tp* _M_ptr; // Contained pointer. - weak_count<_Lp> _M_refcount; // Reference counter. - }; - -// 2.2.4.7 weak_ptr specialized algorithms. -template - void - swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) - { __a.swap(__b); } - - -template - class __enable_shared_from_this - { - protected: - __enable_shared_from_this() { } - - __enable_shared_from_this(const __enable_shared_from_this&) { } - - __enable_shared_from_this& - operator=(const __enable_shared_from_this&) - { return *this; } - - ~__enable_shared_from_this() { } - - public: - __shared_ptr<_Tp, _Lp> - shared_from_this() - { - __shared_ptr<_Tp, _Lp> __p(this->_M_weak_this); - return __p; - } - - __shared_ptr - shared_from_this() const - { - __shared_ptr __p(this->_M_weak_this); - return __p; - } - - private: - template + expired() const // never throws + { return _M_refcount.use_count() == 0; } + void - _M_weak_assign(_Tp1* __p, const shared_count<_Lp>& __n) const - { _M_weak_this._M_assign(__p, __n); } + reset() // never throws + { __weak_ptr().swap(*this); } - template - friend void - __enable_shared_from_this_helper(const shared_count<_Lp>& __pn, - const __enable_shared_from_this* __pe, - const _Tp1* __px) + void + swap(__weak_ptr& __s) // never throws { - if (__pe != 0) - __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); + std::swap(_M_ptr, __s._M_ptr); + _M_refcount.swap(__s._M_refcount); } - mutable __weak_ptr<_Tp, _Lp> _M_weak_this; - }; + private: + template + bool + _M_less(const __weak_ptr<_Tp1, _Lp>& __rhs) const + { return _M_refcount < __rhs._M_refcount; } -template - class shared_ptr; + // Used by __enable_shared_from_this. + void + _M_assign(_Tp* __ptr, const shared_count<_Lp>& __refcount) + { + _M_ptr = __ptr; + _M_refcount = __refcount; + } -// The actual TR1 weak_ptr, with forwarding constructors and -// assignment operators. -template - class weak_ptr : public __weak_ptr<_Tp> - { - public: - weak_ptr() : __weak_ptr<_Tp>() { } + // Friend injected into namespace and found by ADL. + template + friend inline bool + operator<(const __weak_ptr& __lhs, const __weak_ptr<_Tp1, _Lp>& __rhs) + { return __lhs._M_less(__rhs); } + + template friend class __weak_ptr; + template friend class __shared_ptr; + friend class __enable_shared_from_this<_Tp, _Lp>; + + _Tp* _M_ptr; // Contained pointer. + weak_count<_Lp> _M_refcount; // Reference counter. + }; + + // 2.2.4.7 weak_ptr specialized algorithms. + template + void + swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) + { __a.swap(__b); } + + + template + class __enable_shared_from_this + { + protected: + __enable_shared_from_this() { } + + __enable_shared_from_this(const __enable_shared_from_this&) { } + + __enable_shared_from_this& + operator=(const __enable_shared_from_this&) + { return *this; } + + ~__enable_shared_from_this() { } + + public: + __shared_ptr<_Tp, _Lp> + shared_from_this() + { + __shared_ptr<_Tp, _Lp> __p(this->_M_weak_this); + return __p; + } + + __shared_ptr + shared_from_this() const + { + __shared_ptr __p(this->_M_weak_this); + return __p; + } + + private: + template + void + _M_weak_assign(_Tp1* __p, const shared_count<_Lp>& __n) const + { _M_weak_this._M_assign(__p, __n); } + + template + friend void + __enable_shared_from_this_helper(const shared_count<_Lp>& __pn, + const __enable_shared_from_this* __pe, + const _Tp1* __px) + { + if (__pe != 0) + __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); + } + + mutable __weak_ptr<_Tp, _Lp> _M_weak_this; + }; + + template + class shared_ptr; + + // The actual TR1 weak_ptr, with forwarding constructors and + // assignment operators. + template + class weak_ptr : public __weak_ptr<_Tp> + { + public: + weak_ptr() : __weak_ptr<_Tp>() { } + + template + weak_ptr(const __weak_ptr<_Tp1>& r) : __weak_ptr<_Tp>(r) { } + + template + weak_ptr(const __shared_ptr<_Tp1>& r) : __weak_ptr<_Tp>(r) { } + + template + weak_ptr& + operator=(const weak_ptr<_Tp1>& r) // never throws + { + this->__weak_ptr<_Tp>::operator=(r); + return *this; + } + + template + weak_ptr& + operator=(const shared_ptr<_Tp1>& r) // never throws + { + this->__weak_ptr<_Tp>::operator=(r); + return *this; + } + }; + + // The actual TR1 shared_ptr, with forwarding constructors and + // assignment operators. + template + class shared_ptr : public __shared_ptr<_Tp> + { + public: + shared_ptr() : __shared_ptr<_Tp>() { } + + template + explicit + shared_ptr(_Tp1* __p) + : __shared_ptr<_Tp>(__p) { } + + template + shared_ptr(_Tp1* __p, _Deleter __d) + : __shared_ptr<_Tp>(__p, __d) { } + + template + shared_ptr(const __shared_ptr<_Tp1>& __r) + : __shared_ptr<_Tp>(__r) { } + + template + explicit + shared_ptr(const __weak_ptr<_Tp1>& __r) + : __shared_ptr<_Tp>(__r) { } + + template + explicit + shared_ptr(std::auto_ptr<_Tp1>& __r) + : __shared_ptr<_Tp>(__r) { } + + template + shared_ptr(const __shared_ptr<_Tp1>& __r, __static_cast_tag) + : __shared_ptr<_Tp>(__r, __static_cast_tag()) { } + + template + shared_ptr(const __shared_ptr<_Tp1>& __r, __const_cast_tag) + : __shared_ptr<_Tp>(__r, __const_cast_tag()) { } + + template + shared_ptr(const __shared_ptr<_Tp1>& __r, __dynamic_cast_tag) + : __shared_ptr<_Tp>(__r, __dynamic_cast_tag()) { } + + // Additional non-base assignment operators to avoid excessive errors. + template + shared_ptr& + operator=(std::auto_ptr<_Tp1>& __r) + { + this->__shared_ptr<_Tp>::operator=(__r); + return *this; + } + + template + shared_ptr& + operator=(const shared_ptr<_Tp1>& __r) // never throws + { + this->__shared_ptr<_Tp>::operator=(__r); + return *this; + } + }; + + template + class enable_shared_from_this : public __enable_shared_from_this<_Tp> + { + protected: + enable_shared_from_this() + : __enable_shared_from_this<_Tp>() { } + + enable_shared_from_this(const enable_shared_from_this&) + : __enable_shared_from_this<_Tp>(enable_shared_from_this<_Tp>()) { } + }; - template - weak_ptr(const __weak_ptr<_Tp1>& r) : __weak_ptr<_Tp>(r) { } - - template - weak_ptr(const __shared_ptr<_Tp1>& r) : __weak_ptr<_Tp>(r) { } - - template - weak_ptr& - operator=(const weak_ptr<_Tp1>& r) // never throws - { - this->__weak_ptr<_Tp>::operator=(r); - return *this; - } - - template - weak_ptr& - operator=(const shared_ptr<_Tp1>& r) // never throws - { - this->__weak_ptr<_Tp>::operator=(r); - return *this; - } - }; - -// The actual TR1 shared_ptr, with forwarding constructors and -// assignment operators. -template - class shared_ptr : public __shared_ptr<_Tp> - { - public: - shared_ptr() : __shared_ptr<_Tp>() { } - - template - explicit shared_ptr(_Tp1* __p) - : __shared_ptr<_Tp>(__p) { } - - template - shared_ptr(_Tp1* __p, _Deleter __d) - : __shared_ptr<_Tp>(__p, __d) { } - - template - shared_ptr(const __shared_ptr<_Tp1>& __r) - : __shared_ptr<_Tp>(__r) { } - - template - explicit shared_ptr(const __weak_ptr<_Tp1>& __r) - : __shared_ptr<_Tp>(__r) { } - - template - explicit shared_ptr(std::auto_ptr<_Tp1>& __r) - : __shared_ptr<_Tp>(__r) { } - - template - shared_ptr(const __shared_ptr<_Tp1>& __r, __static_cast_tag) - : __shared_ptr<_Tp>(__r, __static_cast_tag()) { } - - template - shared_ptr(const __shared_ptr<_Tp1>& __r, __const_cast_tag) - : __shared_ptr<_Tp>(__r, __const_cast_tag()) { } - - template - shared_ptr(const __shared_ptr<_Tp1>& __r, __dynamic_cast_tag) - : __shared_ptr<_Tp>(__r, __dynamic_cast_tag()) { } - - // Additional non-base assignment operators to avoid excessive errors. - template - shared_ptr& - operator=(std::auto_ptr<_Tp1>& __r) - { - this->__shared_ptr<_Tp>::operator=(__r); - return *this; - } - - template - shared_ptr& - operator=(const shared_ptr<_Tp1>& __r) // never throws - { - this->__shared_ptr<_Tp>::operator=(__r); - return *this; - } - }; - -template - class enable_shared_from_this : public __enable_shared_from_this<_Tp> - { - protected: - enable_shared_from_this() - : __enable_shared_from_this<_Tp>() { } - - enable_shared_from_this(const enable_shared_from_this&) - : __enable_shared_from_this<_Tp>(enable_shared_from_this<_Tp>()) { } - }; - _GLIBCXX_END_NAMESPACE } // namespace std