diff options
Diffstat (limited to 'libcxx/include/memory')
| -rw-r--r-- | libcxx/include/memory | 3421 |
1 files changed, 48 insertions, 3373 deletions
diff --git a/libcxx/include/memory b/libcxx/include/memory index a00916c8c03f..fdb894353008 100644 --- a/libcxx/include/memory +++ b/libcxx/include/memory @@ -99,7 +99,7 @@ struct allocator_traits }; template <> -class allocator<void> // deprecated in C++17, removed in C++20 +class allocator<void> // removed in C++20 { public: typedef void* pointer; @@ -153,14 +153,17 @@ template <class T, class U> bool operator!=(const allocator<T>&, const allocator<U>&) noexcept; // constexpr in C++20 template <class OutputIterator, class T> -class raw_storage_iterator - : public iterator<output_iterator_tag, - T, // purposefully not C++03 - ptrdiff_t, // purposefully not C++03 - T*, // purposefully not C++03 - raw_storage_iterator&> // purposefully not C++03 +class raw_storage_iterator // deprecated in C++17, removed in C++20 + : public iterator<output_iterator_tag, void, void, void, void> // until C++17 { public: + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; // until C++20 + typedef ptrdiff_t difference_type; // since C++20 + typedef void pointer; + typedef void reference; + explicit raw_storage_iterator(OutputIterator x); raw_storage_iterator& operator*(); raw_storage_iterator& operator=(const T& element); @@ -651,12 +654,12 @@ template <class T, class Alloc> inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value; // Pointer safety -enum class pointer_safety { relaxed, preferred, strict }; -void declare_reachable(void *p); -template <class T> T *undeclare_reachable(T *p); -void declare_no_pointers(char *p, size_t n); -void undeclare_no_pointers(char *p, size_t n); -pointer_safety get_pointer_safety() noexcept; +enum class pointer_safety { relaxed, preferred, strict }; // since C++11 +void declare_reachable(void *p); // since C++11 +template <class T> T *undeclare_reachable(T *p); // since C++11 +void declare_no_pointers(char *p, size_t n); // since C++11 +void undeclare_no_pointers(char *p, size_t n); // since C++11 +pointer_safety get_pointer_safety() noexcept; // since C++11 void* align(size_t alignment, size_t size, void*& ptr, size_t& space); @@ -665,29 +668,40 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space); */ #include <__config> -#include <__availability> -#include <type_traits> -#include <typeinfo> +#include <__functional_base> +#include <__memory/addressof.h> +#include <__memory/allocation_guard.h> +#include <__memory/allocator.h> +#include <__memory/allocator_arg_t.h> +#include <__memory/allocator_traits.h> +#include <__memory/compressed_pair.h> +#include <__memory/construct_at.h> +#include <__memory/pointer_safety.h> +#include <__memory/pointer_traits.h> +#include <__memory/raw_storage_iterator.h> +#include <__memory/shared_ptr.h> +#include <__memory/temporary_buffer.h> +#include <__memory/uninitialized_algorithms.h> +#include <__memory/unique_ptr.h> +#include <__memory/uses_allocator.h> +#include <compare> #include <cstddef> #include <cstdint> -#include <new> -#include <utility> -#include <limits> -#include <iterator> -#include <__functional_base> +#include <cstring> #include <iosfwd> -#include <tuple> +#include <iterator> +#include <new> #include <stdexcept> -#include <cstring> -#include <__memory/allocator_traits.h> -#include <__memory/base.h> -#include <__memory/pointer_traits.h> -#include <__memory/utilities.h> -#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER) -# include <atomic> -#endif +#include <tuple> +#include <type_traits> +#include <typeinfo> +#include <utility> #include <version> +#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) +# include <__memory/auto_ptr.h> +#endif + #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif @@ -698,286 +712,6 @@ _LIBCPP_PUSH_MACROS _LIBCPP_BEGIN_NAMESPACE_STD -template <class _ValueType> -inline _LIBCPP_INLINE_VISIBILITY -_ValueType __libcpp_relaxed_load(_ValueType const* __value) { -#if !defined(_LIBCPP_HAS_NO_THREADS) && \ - defined(__ATOMIC_RELAXED) && \ - (__has_builtin(__atomic_load_n) || defined(_LIBCPP_COMPILER_GCC)) - return __atomic_load_n(__value, __ATOMIC_RELAXED); -#else - return *__value; -#endif -} - -template <class _ValueType> -inline _LIBCPP_INLINE_VISIBILITY -_ValueType __libcpp_acquire_load(_ValueType const* __value) { -#if !defined(_LIBCPP_HAS_NO_THREADS) && \ - defined(__ATOMIC_ACQUIRE) && \ - (__has_builtin(__atomic_load_n) || defined(_LIBCPP_COMPILER_GCC)) - return __atomic_load_n(__value, __ATOMIC_ACQUIRE); -#else - return *__value; -#endif -} - -template <bool _UsePointerTraits> struct __to_address_helper; - -template <> struct __to_address_helper<true> { - template <class _Pointer> - using __return_type = decltype(pointer_traits<_Pointer>::to_address(_VSTD::declval<const _Pointer&>())); - - template <class _Pointer> - _LIBCPP_CONSTEXPR - static __return_type<_Pointer> - __do_it(const _Pointer &__p) _NOEXCEPT { return pointer_traits<_Pointer>::to_address(__p); } -}; - -template <class _Pointer, bool _Dummy = true> -using __choose_to_address = __to_address_helper<_IsValidExpansion<__to_address_helper<_Dummy>::template __return_type, _Pointer>::value>; - - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR -_Tp* -__to_address(_Tp* __p) _NOEXCEPT -{ - static_assert(!is_function<_Tp>::value, "_Tp is a function type"); - return __p; -} - -template <class _Pointer> -inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR -typename __choose_to_address<_Pointer>::template __return_type<_Pointer> -__to_address(const _Pointer& __p) _NOEXCEPT { - return __choose_to_address<_Pointer>::__do_it(__p); -} - -template <> struct __to_address_helper<false> { - template <class _Pointer> - using __return_type = typename pointer_traits<_Pointer>::element_type*; - - template <class _Pointer> - _LIBCPP_CONSTEXPR - static __return_type<_Pointer> - __do_it(const _Pointer &__p) _NOEXCEPT { return _VSTD::__to_address(__p.operator->()); } -}; - - -#if _LIBCPP_STD_VER > 17 -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY constexpr -_Tp* -to_address(_Tp* __p) _NOEXCEPT -{ - static_assert(!is_function_v<_Tp>, "_Tp is a function type"); - return __p; -} - -template <class _Pointer> -inline _LIBCPP_INLINE_VISIBILITY constexpr -auto -to_address(const _Pointer& __p) _NOEXCEPT -{ - return _VSTD::__to_address(__p); -} -#endif - -template <class _Tp> class allocator; - -#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS) -template <> -class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 allocator<void> -{ -public: - typedef void* pointer; - typedef const void* const_pointer; - typedef void value_type; - - template <class _Up> struct rebind {typedef allocator<_Up> other;}; -}; - -template <> -class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 allocator<const void> -{ -public: - typedef const void* pointer; - typedef const void* const_pointer; - typedef const void value_type; - - template <class _Up> struct rebind {typedef allocator<_Up> other;}; -}; -#endif - -// allocator - -template <class _Tp> -class _LIBCPP_TEMPLATE_VIS allocator -{ -public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef _Tp value_type; - typedef true_type propagate_on_container_move_assignment; - typedef true_type is_always_equal; - - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 - allocator() _NOEXCEPT { } - - template <class _Up> - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 - allocator(const allocator<_Up>&) _NOEXCEPT { } - - _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 - _Tp* allocate(size_t __n) { - if (__n > allocator_traits<allocator>::max_size(*this)) - __throw_length_error("allocator<T>::allocate(size_t n)" - " 'n' exceeds maximum supported size"); - if (__libcpp_is_constant_evaluated()) { - return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); - } else { - return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp))); - } - } - - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 - void deallocate(_Tp* __p, size_t __n) _NOEXCEPT { - if (__libcpp_is_constant_evaluated()) { - ::operator delete(__p); - } else { - _VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)); - } - } - - // C++20 Removed members -#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS) - _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp* pointer; - _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer; - _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp& reference; - _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference; - - template <class _Up> - struct _LIBCPP_DEPRECATED_IN_CXX17 rebind { - typedef allocator<_Up> other; - }; - - _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY - pointer address(reference __x) const _NOEXCEPT { - return _VSTD::addressof(__x); - } - _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY - const_pointer address(const_reference __x) const _NOEXCEPT { - return _VSTD::addressof(__x); - } - - _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 - _Tp* allocate(size_t __n, const void*) { - return allocate(__n); - } - - _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT { - return size_type(~0) / sizeof(_Tp); - } - - template <class _Up, class... _Args> - _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY - void construct(_Up* __p, _Args&&... __args) { - ::new ((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); - } - - _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY - void destroy(pointer __p) { - __p->~_Tp(); - } -#endif -}; - -template <class _Tp> -class _LIBCPP_TEMPLATE_VIS allocator<const _Tp> -{ -public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef const _Tp value_type; - typedef true_type propagate_on_container_move_assignment; - typedef true_type is_always_equal; - - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 - allocator() _NOEXCEPT { } - - template <class _Up> - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 - allocator(const allocator<_Up>&) _NOEXCEPT { } - - _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 - const _Tp* allocate(size_t __n) { - if (__n > allocator_traits<allocator>::max_size(*this)) - __throw_length_error("allocator<const T>::allocate(size_t n)" - " 'n' exceeds maximum supported size"); - if (__libcpp_is_constant_evaluated()) { - return static_cast<const _Tp*>(::operator new(__n * sizeof(_Tp))); - } else { - return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp))); - } - } - - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 - void deallocate(const _Tp* __p, size_t __n) { - if (__libcpp_is_constant_evaluated()) { - ::operator delete(const_cast<_Tp*>(__p)); - } else { - _VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)); - } - } - - // C++20 Removed members -#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS) - _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* pointer; - _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer; - _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& reference; - _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference; - - template <class _Up> - struct _LIBCPP_DEPRECATED_IN_CXX17 rebind { - typedef allocator<_Up> other; - }; - - _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY - const_pointer address(const_reference __x) const _NOEXCEPT { - return _VSTD::addressof(__x); - } - - _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17 - const _Tp* allocate(size_t __n, const void*) { - return allocate(__n); - } - - _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT { - return size_type(~0) / sizeof(_Tp); - } - - template <class _Up, class... _Args> - _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY - void construct(_Up* __p, _Args&&... __args) { - ::new ((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); - } - - _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY - void destroy(pointer __p) { - __p->~_Tp(); - } -#endif -}; - -template <class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 -bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;} - -template <class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 -bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;} - template <class _Alloc, class _Ptr> _LIBCPP_INLINE_VISIBILITY void __construct_forward_with_exception_guarantees(_Alloc& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2) { @@ -1062,1045 +796,9 @@ void __construct_backward_with_exception_guarantees(_Alloc&, _Tp* __begin1, _Tp* ptrdiff_t _Np = __end1 - __begin1; __end2 -= _Np; if (_Np > 0) - _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp)); + _VSTD::memcpy(static_cast<void*>(__end2), static_cast<void const*>(__begin1), _Np * sizeof(_Tp)); } -template <class _OutputIterator, class _Tp> -class _LIBCPP_TEMPLATE_VIS raw_storage_iterator - : public iterator<output_iterator_tag, - _Tp, // purposefully not C++03 - ptrdiff_t, // purposefully not C++03 - _Tp*, // purposefully not C++03 - raw_storage_iterator<_OutputIterator, _Tp>&> // purposefully not C++03 -{ -private: - _OutputIterator __x_; -public: - _LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {} - _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator*() {return *this;} - _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element) - {::new ((void*)_VSTD::addressof(*__x_)) _Tp(__element); return *this;} -#if _LIBCPP_STD_VER >= 14 - _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(_Tp&& __element) - {::new ((void*)_VSTD::addressof(*__x_)) _Tp(_VSTD::move(__element)); return *this;} -#endif - _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator++() {++__x_; return *this;} - _LIBCPP_INLINE_VISIBILITY raw_storage_iterator operator++(int) - {raw_storage_iterator __t(*this); ++__x_; return __t;} -#if _LIBCPP_STD_VER >= 14 - _LIBCPP_INLINE_VISIBILITY _OutputIterator base() const { return __x_; } -#endif -}; - -template <class _Tp> -_LIBCPP_NODISCARD_EXT _LIBCPP_NO_CFI -pair<_Tp*, ptrdiff_t> -get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT -{ - pair<_Tp*, ptrdiff_t> __r(0, 0); - const ptrdiff_t __m = (~ptrdiff_t(0) ^ - ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1))) - / sizeof(_Tp); - if (__n > __m) - __n = __m; - while (__n > 0) - { -#if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) - if (__is_overaligned_for_new(_LIBCPP_ALIGNOF(_Tp))) - { - align_val_t __al = - align_val_t(alignment_of<_Tp>::value); - __r.first = static_cast<_Tp*>(::operator new( - __n * sizeof(_Tp), __al, nothrow)); - } else { - __r.first = static_cast<_Tp*>(::operator new( - __n * sizeof(_Tp), nothrow)); - } -#else - if (__is_overaligned_for_new(_LIBCPP_ALIGNOF(_Tp))) - { - // Since aligned operator new is unavailable, return an empty - // buffer rather than one with invalid alignment. - return __r; - } - - __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), nothrow)); -#endif - - if (__r.first) - { - __r.second = __n; - break; - } - __n /= 2; - } - return __r; -} - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -void return_temporary_buffer(_Tp* __p) _NOEXCEPT -{ - _VSTD::__libcpp_deallocate_unsized((void*)__p, _LIBCPP_ALIGNOF(_Tp)); -} - -#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) -template <class _Tp> -struct _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr_ref -{ - _Tp* __ptr_; -}; - -template<class _Tp> -class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr -{ -private: - _Tp* __ptr_; -public: - typedef _Tp element_type; - - _LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) _NOEXCEPT : __ptr_(__p) {} - _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) _NOEXCEPT : __ptr_(__p.release()) {} - template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) _NOEXCEPT - : __ptr_(__p.release()) {} - _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) _NOEXCEPT - {reset(__p.release()); return *this;} - template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) _NOEXCEPT - {reset(__p.release()); return *this;} - _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) _NOEXCEPT - {reset(__p.__ptr_); return *this;} - _LIBCPP_INLINE_VISIBILITY ~auto_ptr() _NOEXCEPT {delete __ptr_;} - - _LIBCPP_INLINE_VISIBILITY _Tp& operator*() const _NOEXCEPT - {return *__ptr_;} - _LIBCPP_INLINE_VISIBILITY _Tp* operator->() const _NOEXCEPT {return __ptr_;} - _LIBCPP_INLINE_VISIBILITY _Tp* get() const _NOEXCEPT {return __ptr_;} - _LIBCPP_INLINE_VISIBILITY _Tp* release() _NOEXCEPT - { - _Tp* __t = __ptr_; - __ptr_ = nullptr; - return __t; - } - _LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = 0) _NOEXCEPT - { - if (__ptr_ != __p) - delete __ptr_; - __ptr_ = __p; - } - - _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) _NOEXCEPT : __ptr_(__p.__ptr_) {} - template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() _NOEXCEPT - {auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;} - template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() _NOEXCEPT - {return auto_ptr<_Up>(release());} -}; - -template <> -class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr<void> -{ -public: - typedef void element_type; -}; -#endif - -// Tag used to default initialize one or both of the pair's elements. -struct __default_init_tag {}; -struct __value_init_tag {}; - -template <class _Tp, int _Idx, - bool _CanBeEmptyBase = - is_empty<_Tp>::value && !__libcpp_is_final<_Tp>::value> -struct __compressed_pair_elem { - typedef _Tp _ParamT; - typedef _Tp& reference; - typedef const _Tp& const_reference; - - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR - __compressed_pair_elem(__default_init_tag) {} - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR - __compressed_pair_elem(__value_init_tag) : __value_() {} - - template <class _Up, class = typename enable_if< - !is_same<__compressed_pair_elem, typename decay<_Up>::type>::value - >::type> - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR explicit - __compressed_pair_elem(_Up&& __u) - : __value_(_VSTD::forward<_Up>(__u)) - { - } - - -#ifndef _LIBCPP_CXX03_LANG - template <class... _Args, size_t... _Indexes> - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 - __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, - __tuple_indices<_Indexes...>) - : __value_(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {} -#endif - - - _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return __value_; } - _LIBCPP_INLINE_VISIBILITY - const_reference __get() const _NOEXCEPT { return __value_; } - -private: - _Tp __value_; -}; - -template <class _Tp, int _Idx> -struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp { - typedef _Tp _ParamT; - typedef _Tp& reference; - typedef const _Tp& const_reference; - typedef _Tp __value_type; - - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __compressed_pair_elem() = default; - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR - __compressed_pair_elem(__default_init_tag) {} - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR - __compressed_pair_elem(__value_init_tag) : __value_type() {} - - template <class _Up, class = typename enable_if< - !is_same<__compressed_pair_elem, typename decay<_Up>::type>::value - >::type> - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR explicit - __compressed_pair_elem(_Up&& __u) - : __value_type(_VSTD::forward<_Up>(__u)) - {} - -#ifndef _LIBCPP_CXX03_LANG - template <class... _Args, size_t... _Indexes> - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 - __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, - __tuple_indices<_Indexes...>) - : __value_type(_VSTD::forward<_Args>(_VSTD::get<_Indexes>(__args))...) {} -#endif - - _LIBCPP_INLINE_VISIBILITY reference __get() _NOEXCEPT { return *this; } - _LIBCPP_INLINE_VISIBILITY - const_reference __get() const _NOEXCEPT { return *this; } -}; - -template <class _T1, class _T2> -class __compressed_pair : private __compressed_pair_elem<_T1, 0>, - private __compressed_pair_elem<_T2, 1> { -public: - // NOTE: This static assert should never fire because __compressed_pair - // is *almost never* used in a scenario where it's possible for T1 == T2. - // (The exception is std::function where it is possible that the function - // object and the allocator have the same type). - static_assert((!is_same<_T1, _T2>::value), - "__compressed_pair cannot be instantiated when T1 and T2 are the same type; " - "The current implementation is NOT ABI-compatible with the previous " - "implementation for this configuration"); - - typedef _LIBCPP_NODEBUG_TYPE __compressed_pair_elem<_T1, 0> _Base1; - typedef _LIBCPP_NODEBUG_TYPE __compressed_pair_elem<_T2, 1> _Base2; - - template <bool _Dummy = true, - class = typename enable_if< - __dependent_type<is_default_constructible<_T1>, _Dummy>::value && - __dependent_type<is_default_constructible<_T2>, _Dummy>::value - >::type - > - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR __compressed_pair() : _Base1(__value_init_tag()), _Base2(__value_init_tag()) {} - - template <class _U1, class _U2> - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR - __compressed_pair(_U1&& __t1, _U2&& __t2) - : _Base1(_VSTD::forward<_U1>(__t1)), _Base2(_VSTD::forward<_U2>(__t2)) {} - -#ifndef _LIBCPP_CXX03_LANG - template <class... _Args1, class... _Args2> - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 - __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, - tuple<_Args2...> __second_args) - : _Base1(__pc, _VSTD::move(__first_args), - typename __make_tuple_indices<sizeof...(_Args1)>::type()), - _Base2(__pc, _VSTD::move(__second_args), - typename __make_tuple_indices<sizeof...(_Args2)>::type()) {} -#endif - - _LIBCPP_INLINE_VISIBILITY - typename _Base1::reference first() _NOEXCEPT { - return static_cast<_Base1&>(*this).__get(); - } - - _LIBCPP_INLINE_VISIBILITY - typename _Base1::const_reference first() const _NOEXCEPT { - return static_cast<_Base1 const&>(*this).__get(); - } - - _LIBCPP_INLINE_VISIBILITY - typename _Base2::reference second() _NOEXCEPT { - return static_cast<_Base2&>(*this).__get(); - } - - _LIBCPP_INLINE_VISIBILITY - typename _Base2::const_reference second() const _NOEXCEPT { - return static_cast<_Base2 const&>(*this).__get(); - } - - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR - static _Base1* __get_first_base(__compressed_pair* __pair) _NOEXCEPT { - return static_cast<_Base1*>(__pair); - } - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR - static _Base2* __get_second_base(__compressed_pair* __pair) _NOEXCEPT { - return static_cast<_Base2*>(__pair); - } - - _LIBCPP_INLINE_VISIBILITY - void swap(__compressed_pair& __x) - _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && - __is_nothrow_swappable<_T2>::value) - { - using _VSTD::swap; - swap(first(), __x.first()); - swap(second(), __x.second()); - } -}; - -template <class _T1, class _T2> -inline _LIBCPP_INLINE_VISIBILITY -void swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y) - _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && - __is_nothrow_swappable<_T2>::value) { - __x.swap(__y); -} - -// default_delete - -template <class _Tp> -struct _LIBCPP_TEMPLATE_VIS default_delete { - static_assert(!is_function<_Tp>::value, - "default_delete cannot be instantiated for function types"); -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default; -#else - _LIBCPP_INLINE_VISIBILITY default_delete() {} -#endif - template <class _Up> - _LIBCPP_INLINE_VISIBILITY - default_delete(const default_delete<_Up>&, - typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = - 0) _NOEXCEPT {} - - _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __ptr) const _NOEXCEPT { - static_assert(sizeof(_Tp) > 0, - "default_delete can not delete incomplete type"); - static_assert(!is_void<_Tp>::value, - "default_delete can not delete incomplete type"); - delete __ptr; - } -}; - -template <class _Tp> -struct _LIBCPP_TEMPLATE_VIS default_delete<_Tp[]> { -private: - template <class _Up> - struct _EnableIfConvertible - : enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value> {}; - -public: -#ifndef _LIBCPP_CXX03_LANG - _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default; -#else - _LIBCPP_INLINE_VISIBILITY default_delete() {} -#endif - - template <class _Up> - _LIBCPP_INLINE_VISIBILITY - default_delete(const default_delete<_Up[]>&, - typename _EnableIfConvertible<_Up>::type* = 0) _NOEXCEPT {} - - template <class _Up> - _LIBCPP_INLINE_VISIBILITY - typename _EnableIfConvertible<_Up>::type - operator()(_Up* __ptr) const _NOEXCEPT { - static_assert(sizeof(_Tp) > 0, - "default_delete can not delete incomplete type"); - static_assert(!is_void<_Tp>::value, - "default_delete can not delete void type"); - delete[] __ptr; - } -}; - -template <class _Deleter> -struct __unique_ptr_deleter_sfinae { - static_assert(!is_reference<_Deleter>::value, "incorrect specialization"); - typedef const _Deleter& __lval_ref_type; - typedef _Deleter&& __good_rval_ref_type; - typedef true_type __enable_rval_overload; -}; - -template <class _Deleter> -struct __unique_ptr_deleter_sfinae<_Deleter const&> { - typedef const _Deleter& __lval_ref_type; - typedef const _Deleter&& __bad_rval_ref_type; - typedef false_type __enable_rval_overload; -}; - -template <class _Deleter> -struct __unique_ptr_deleter_sfinae<_Deleter&> { - typedef _Deleter& __lval_ref_type; - typedef _Deleter&& __bad_rval_ref_type; - typedef false_type __enable_rval_overload; -}; - -#if defined(_LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI) -# define _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI __attribute__((trivial_abi)) -#else -# define _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI -#endif - -template <class _Tp, class _Dp = default_delete<_Tp> > -class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr { -public: - typedef _Tp element_type; - typedef _Dp deleter_type; - typedef _LIBCPP_NODEBUG_TYPE typename __pointer<_Tp, deleter_type>::type pointer; - - static_assert(!is_rvalue_reference<deleter_type>::value, - "the specified deleter type cannot be an rvalue reference"); - -private: - __compressed_pair<pointer, deleter_type> __ptr_; - - struct __nat { int __for_bool_; }; - - typedef _LIBCPP_NODEBUG_TYPE __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE; - - template <bool _Dummy> - using _LValRefType _LIBCPP_NODEBUG_TYPE = - typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type; - - template <bool _Dummy> - using _GoodRValRefType _LIBCPP_NODEBUG_TYPE = - typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type; - - template <bool _Dummy> - using _BadRValRefType _LIBCPP_NODEBUG_TYPE = - typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type; - - template <bool _Dummy, class _Deleter = typename __dependent_type< - __identity<deleter_type>, _Dummy>::type> - using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG_TYPE = - typename enable_if<is_default_constructible<_Deleter>::value && - !is_pointer<_Deleter>::value>::type; - - template <class _ArgType> - using _EnableIfDeleterConstructible _LIBCPP_NODEBUG_TYPE = - typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type; - - template <class _UPtr, class _Up> - using _EnableIfMoveConvertible _LIBCPP_NODEBUG_TYPE = typename enable_if< - is_convertible<typename _UPtr::pointer, pointer>::value && - !is_array<_Up>::value - >::type; - - template <class _UDel> - using _EnableIfDeleterConvertible _LIBCPP_NODEBUG_TYPE = typename enable_if< - (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) || - (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value) - >::type; - - template <class _UDel> - using _EnableIfDeleterAssignable = typename enable_if< - is_assignable<_Dp&, _UDel&&>::value - >::type; - -public: - template <bool _Dummy = true, - class = _EnableIfDeleterDefaultConstructible<_Dummy> > - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {} - - template <bool _Dummy = true, - class = _EnableIfDeleterDefaultConstructible<_Dummy> > - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {} - - template <bool _Dummy = true, - class = _EnableIfDeleterDefaultConstructible<_Dummy> > - _LIBCPP_INLINE_VISIBILITY - explicit unique_ptr(pointer __p) _NOEXCEPT : __ptr_(__p, __default_init_tag()) {} - - template <bool _Dummy = true, - class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > > - _LIBCPP_INLINE_VISIBILITY - unique_ptr(pointer __p, _LValRefType<_Dummy> __d) _NOEXCEPT - : __ptr_(__p, __d) {} - - template <bool _Dummy = true, - class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > > - _LIBCPP_INLINE_VISIBILITY - unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT - : __ptr_(__p, _VSTD::move(__d)) { - static_assert(!is_reference<deleter_type>::value, - "rvalue deleter bound to reference"); - } - - template <bool _Dummy = true, - class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> > > - _LIBCPP_INLINE_VISIBILITY - unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete; - - _LIBCPP_INLINE_VISIBILITY - unique_ptr(unique_ptr&& __u) _NOEXCEPT - : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) { - } - - template <class _Up, class _Ep, - class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, - class = _EnableIfDeleterConvertible<_Ep> - > - _LIBCPP_INLINE_VISIBILITY - unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT - : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {} - -#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) - template <class _Up> - _LIBCPP_INLINE_VISIBILITY - unique_ptr(auto_ptr<_Up>&& __p, - typename enable_if<is_convertible<_Up*, _Tp*>::value && - is_same<_Dp, default_delete<_Tp> >::value, - __nat>::type = __nat()) _NOEXCEPT - : __ptr_(__p.release(), __default_init_tag()) {} -#endif - - _LIBCPP_INLINE_VISIBILITY - unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT { - reset(__u.release()); - __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); - return *this; - } - - template <class _Up, class _Ep, - class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, - class = _EnableIfDeleterAssignable<_Ep> - > - _LIBCPP_INLINE_VISIBILITY - unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT { - reset(__u.release()); - __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); - return *this; - } - -#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) - template <class _Up> - _LIBCPP_INLINE_VISIBILITY - typename enable_if<is_convertible<_Up*, _Tp*>::value && - is_same<_Dp, default_delete<_Tp> >::value, - unique_ptr&>::type - operator=(auto_ptr<_Up> __p) { - reset(__p.release()); - return *this; - } -#endif - -#ifdef _LIBCPP_CXX03_LANG - unique_ptr(unique_ptr const&) = delete; - unique_ptr& operator=(unique_ptr const&) = delete; -#endif - - - _LIBCPP_INLINE_VISIBILITY - ~unique_ptr() { reset(); } - - _LIBCPP_INLINE_VISIBILITY - unique_ptr& operator=(nullptr_t) _NOEXCEPT { - reset(); - return *this; - } - - _LIBCPP_INLINE_VISIBILITY - typename add_lvalue_reference<_Tp>::type - operator*() const { - return *__ptr_.first(); - } - _LIBCPP_INLINE_VISIBILITY - pointer operator->() const _NOEXCEPT { - return __ptr_.first(); - } - _LIBCPP_INLINE_VISIBILITY - pointer get() const _NOEXCEPT { - return __ptr_.first(); - } - _LIBCPP_INLINE_VISIBILITY - deleter_type& get_deleter() _NOEXCEPT { - return __ptr_.second(); - } - _LIBCPP_INLINE_VISIBILITY - const deleter_type& get_deleter() const _NOEXCEPT { - return __ptr_.second(); - } - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT { - return __ptr_.first() != nullptr; - } - - _LIBCPP_INLINE_VISIBILITY - pointer release() _NOEXCEPT { - pointer __t = __ptr_.first(); - __ptr_.first() = pointer(); - return __t; - } - - _LIBCPP_INLINE_VISIBILITY - void reset(pointer __p = pointer()) _NOEXCEPT { - pointer __tmp = __ptr_.first(); - __ptr_.first() = __p; - if (__tmp) - __ptr_.second()(__tmp); - } - - _LIBCPP_INLINE_VISIBILITY - void swap(unique_ptr& __u) _NOEXCEPT { - __ptr_.swap(__u.__ptr_); - } -}; - - -template <class _Tp, class _Dp> -class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp> { -public: - typedef _Tp element_type; - typedef _Dp deleter_type; - typedef typename __pointer<_Tp, deleter_type>::type pointer; - -private: - __compressed_pair<pointer, deleter_type> __ptr_; - - template <class _From> - struct _CheckArrayPointerConversion : is_same<_From, pointer> {}; - - template <class _FromElem> - struct _CheckArrayPointerConversion<_FromElem*> - : integral_constant<bool, - is_same<_FromElem*, pointer>::value || - (is_same<pointer, element_type*>::value && - is_convertible<_FromElem(*)[], element_type(*)[]>::value) - > - {}; - - typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE; - - template <bool _Dummy> - using _LValRefType _LIBCPP_NODEBUG_TYPE = - typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type; - - template <bool _Dummy> - using _GoodRValRefType _LIBCPP_NODEBUG_TYPE = - typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type; - - template <bool _Dummy> - using _BadRValRefType _LIBCPP_NODEBUG_TYPE = - typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type; - - template <bool _Dummy, class _Deleter = typename __dependent_type< - __identity<deleter_type>, _Dummy>::type> - using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG_TYPE = - typename enable_if<is_default_constructible<_Deleter>::value && - !is_pointer<_Deleter>::value>::type; - - template <class _ArgType> - using _EnableIfDeleterConstructible _LIBCPP_NODEBUG_TYPE = - typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type; - - template <class _Pp> - using _EnableIfPointerConvertible _LIBCPP_NODEBUG_TYPE = typename enable_if< - _CheckArrayPointerConversion<_Pp>::value - >::type; - - template <class _UPtr, class _Up, - class _ElemT = typename _UPtr::element_type> - using _EnableIfMoveConvertible _LIBCPP_NODEBUG_TYPE = typename enable_if< - is_array<_Up>::value && - is_same<pointer, element_type*>::value && - is_same<typename _UPtr::pointer, _ElemT*>::value && - is_convertible<_ElemT(*)[], element_type(*)[]>::value - >::type; - - template <class _UDel> - using _EnableIfDeleterConvertible _LIBCPP_NODEBUG_TYPE = typename enable_if< - (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) || - (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value) - >::type; - - template <class _UDel> - using _EnableIfDeleterAssignable _LIBCPP_NODEBUG_TYPE = typename enable_if< - is_assignable<_Dp&, _UDel&&>::value - >::type; - -public: - template <bool _Dummy = true, - class = _EnableIfDeleterDefaultConstructible<_Dummy> > - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {} - - template <bool _Dummy = true, - class = _EnableIfDeleterDefaultConstructible<_Dummy> > - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer(), __default_init_tag()) {} - - template <class _Pp, bool _Dummy = true, - class = _EnableIfDeleterDefaultConstructible<_Dummy>, - class = _EnableIfPointerConvertible<_Pp> > - _LIBCPP_INLINE_VISIBILITY - explicit unique_ptr(_Pp __p) _NOEXCEPT - : __ptr_(__p, __default_init_tag()) {} - - template <class _Pp, bool _Dummy = true, - class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> >, - class = _EnableIfPointerConvertible<_Pp> > - _LIBCPP_INLINE_VISIBILITY - unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) _NOEXCEPT - : __ptr_(__p, __d) {} - - template <bool _Dummy = true, - class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > > - _LIBCPP_INLINE_VISIBILITY - unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) _NOEXCEPT - : __ptr_(nullptr, __d) {} - - template <class _Pp, bool _Dummy = true, - class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> >, - class = _EnableIfPointerConvertible<_Pp> > - _LIBCPP_INLINE_VISIBILITY - unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT - : __ptr_(__p, _VSTD::move(__d)) { - static_assert(!is_reference<deleter_type>::value, - "rvalue deleter bound to reference"); - } - - template <bool _Dummy = true, - class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > > - _LIBCPP_INLINE_VISIBILITY - unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) _NOEXCEPT - : __ptr_(nullptr, _VSTD::move(__d)) { - static_assert(!is_reference<deleter_type>::value, - "rvalue deleter bound to reference"); - } - - template <class _Pp, bool _Dummy = true, - class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> >, - class = _EnableIfPointerConvertible<_Pp> > - _LIBCPP_INLINE_VISIBILITY - unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete; - - _LIBCPP_INLINE_VISIBILITY - unique_ptr(unique_ptr&& __u) _NOEXCEPT - : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) { - } - - _LIBCPP_INLINE_VISIBILITY - unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT { - reset(__u.release()); - __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); - return *this; - } - - template <class _Up, class _Ep, - class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, - class = _EnableIfDeleterConvertible<_Ep> - > - _LIBCPP_INLINE_VISIBILITY - unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT - : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) { - } - - template <class _Up, class _Ep, - class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>, - class = _EnableIfDeleterAssignable<_Ep> - > - _LIBCPP_INLINE_VISIBILITY - unique_ptr& - operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT { - reset(__u.release()); - __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); - return *this; - } - -#ifdef _LIBCPP_CXX03_LANG - unique_ptr(unique_ptr const&) = delete; - unique_ptr& operator=(unique_ptr const&) = delete; -#endif - -public: - _LIBCPP_INLINE_VISIBILITY - ~unique_ptr() { reset(); } - - _LIBCPP_INLINE_VISIBILITY - unique_ptr& operator=(nullptr_t) _NOEXCEPT { - reset(); - return *this; - } - - _LIBCPP_INLINE_VISIBILITY - typename add_lvalue_reference<_Tp>::type - operator[](size_t __i) const { - return __ptr_.first()[__i]; - } - _LIBCPP_INLINE_VISIBILITY - pointer get() const _NOEXCEPT { - return __ptr_.first(); - } - - _LIBCPP_INLINE_VISIBILITY - deleter_type& get_deleter() _NOEXCEPT { - return __ptr_.second(); - } - - _LIBCPP_INLINE_VISIBILITY - const deleter_type& get_deleter() const _NOEXCEPT { - return __ptr_.second(); - } - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT { - return __ptr_.first() != nullptr; - } - - _LIBCPP_INLINE_VISIBILITY - pointer release() _NOEXCEPT { - pointer __t = __ptr_.first(); - __ptr_.first() = pointer(); - return __t; - } - - template <class _Pp> - _LIBCPP_INLINE_VISIBILITY - typename enable_if< - _CheckArrayPointerConversion<_Pp>::value - >::type - reset(_Pp __p) _NOEXCEPT { - pointer __tmp = __ptr_.first(); - __ptr_.first() = __p; - if (__tmp) - __ptr_.second()(__tmp); - } - - _LIBCPP_INLINE_VISIBILITY - void reset(nullptr_t = nullptr) _NOEXCEPT { - pointer __tmp = __ptr_.first(); - __ptr_.first() = nullptr; - if (__tmp) - __ptr_.second()(__tmp); - } - - _LIBCPP_INLINE_VISIBILITY - void swap(unique_ptr& __u) _NOEXCEPT { - __ptr_.swap(__u.__ptr_); - } - -}; - -template <class _Tp, class _Dp> -inline _LIBCPP_INLINE_VISIBILITY -typename enable_if< - __is_swappable<_Dp>::value, - void ->::type -swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {__x.swap(__y);} - -template <class _T1, class _D1, class _T2, class _D2> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();} - -template <class _T1, class _D1, class _T2, class _D2> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);} - -template <class _T1, class _D1, class _T2, class _D2> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) -{ - typedef typename unique_ptr<_T1, _D1>::pointer _P1; - typedef typename unique_ptr<_T2, _D2>::pointer _P2; - typedef typename common_type<_P1, _P2>::type _Vp; - return less<_Vp>()(__x.get(), __y.get()); -} - -template <class _T1, class _D1, class _T2, class _D2> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator> (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __y < __x;} - -template <class _T1, class _D1, class _T2, class _D2> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);} - -template <class _T1, class _D1, class _T2, class _D2> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT -{ - return !__x; -} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT -{ - return !__x; -} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT -{ - return static_cast<bool>(__x); -} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT -{ - return static_cast<bool>(__x); -} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t) -{ - typedef typename unique_ptr<_T1, _D1>::pointer _P1; - return less<_P1>()(__x.get(), nullptr); -} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x) -{ - typedef typename unique_ptr<_T1, _D1>::pointer _P1; - return less<_P1>()(nullptr, __x.get()); -} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t) -{ - return nullptr < __x; -} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x) -{ - return __x < nullptr; -} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t) -{ - return !(nullptr < __x); -} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x) -{ - return !(__x < nullptr); -} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t) -{ - return !(__x < nullptr); -} - -template <class _T1, class _D1> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x) -{ - return !(nullptr < __x); -} - -#if _LIBCPP_STD_VER > 11 - -template<class _Tp> -struct __unique_if -{ - typedef unique_ptr<_Tp> __unique_single; -}; - -template<class _Tp> -struct __unique_if<_Tp[]> -{ - typedef unique_ptr<_Tp[]> __unique_array_unknown_bound; -}; - -template<class _Tp, size_t _Np> -struct __unique_if<_Tp[_Np]> -{ - typedef void __unique_array_known_bound; -}; - -template<class _Tp, class... _Args> -inline _LIBCPP_INLINE_VISIBILITY -typename __unique_if<_Tp>::__unique_single -make_unique(_Args&&... __args) -{ - return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...)); -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -typename __unique_if<_Tp>::__unique_array_unknown_bound -make_unique(size_t __n) -{ - typedef typename remove_extent<_Tp>::type _Up; - return unique_ptr<_Tp>(new _Up[__n]()); -} - -template<class _Tp, class... _Args> - typename __unique_if<_Tp>::__unique_array_known_bound - make_unique(_Args&&...) = delete; - -#endif // _LIBCPP_STD_VER > 11 - -template <class _Tp, class _Dp> -#ifdef _LIBCPP_CXX03_LANG -struct _LIBCPP_TEMPLATE_VIS hash<unique_ptr<_Tp, _Dp> > -#else -struct _LIBCPP_TEMPLATE_VIS hash<__enable_hash_helper< - unique_ptr<_Tp, _Dp>, typename unique_ptr<_Tp, _Dp>::pointer> > -#endif -{ - typedef unique_ptr<_Tp, _Dp> argument_type; - typedef size_t result_type; - _LIBCPP_INLINE_VISIBILITY - result_type operator()(const argument_type& __ptr) const - { - typedef typename argument_type::pointer pointer; - return hash<pointer>()(__ptr.get()); - } -}; - struct __destruct_n { private: @@ -2140,2029 +838,6 @@ public: {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());} }; -template <class _Alloc> -class __allocator_destructor -{ - typedef _LIBCPP_NODEBUG_TYPE allocator_traits<_Alloc> __alloc_traits; -public: - typedef _LIBCPP_NODEBUG_TYPE typename __alloc_traits::pointer pointer; - typedef _LIBCPP_NODEBUG_TYPE typename __alloc_traits::size_type size_type; -private: - _Alloc& __alloc_; - size_type __s_; -public: - _LIBCPP_INLINE_VISIBILITY __allocator_destructor(_Alloc& __a, size_type __s) - _NOEXCEPT - : __alloc_(__a), __s_(__s) {} - _LIBCPP_INLINE_VISIBILITY - void operator()(pointer __p) _NOEXCEPT - {__alloc_traits::deallocate(__alloc_, __p, __s_);} -}; - -template <class _InputIterator, class _ForwardIterator> -_ForwardIterator -uninitialized_copy(_InputIterator __f, _InputIterator __l, _ForwardIterator __r) -{ - typedef typename iterator_traits<_ForwardIterator>::value_type value_type; -#ifndef _LIBCPP_NO_EXCEPTIONS - _ForwardIterator __s = __r; - try - { -#endif - for (; __f != __l; ++__f, (void) ++__r) - ::new ((void*)_VSTD::addressof(*__r)) value_type(*__f); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - for (; __s != __r; ++__s) - __s->~value_type(); - throw; - } -#endif - return __r; -} - -template <class _InputIterator, class _Size, class _ForwardIterator> -_ForwardIterator -uninitialized_copy_n(_InputIterator __f, _Size __n, _ForwardIterator __r) -{ - typedef typename iterator_traits<_ForwardIterator>::value_type value_type; -#ifndef _LIBCPP_NO_EXCEPTIONS - _ForwardIterator __s = __r; - try - { -#endif - for (; __n > 0; ++__f, (void) ++__r, (void) --__n) - ::new ((void*)_VSTD::addressof(*__r)) value_type(*__f); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - for (; __s != __r; ++__s) - __s->~value_type(); - throw; - } -#endif - return __r; -} - -template <class _ForwardIterator, class _Tp> -void -uninitialized_fill(_ForwardIterator __f, _ForwardIterator __l, const _Tp& __x) -{ - typedef typename iterator_traits<_ForwardIterator>::value_type value_type; -#ifndef _LIBCPP_NO_EXCEPTIONS - _ForwardIterator __s = __f; - try - { -#endif - for (; __f != __l; ++__f) - ::new ((void*)_VSTD::addressof(*__f)) value_type(__x); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - for (; __s != __f; ++__s) - __s->~value_type(); - throw; - } -#endif -} - -template <class _ForwardIterator, class _Size, class _Tp> -_ForwardIterator -uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x) -{ - typedef typename iterator_traits<_ForwardIterator>::value_type value_type; -#ifndef _LIBCPP_NO_EXCEPTIONS - _ForwardIterator __s = __f; - try - { -#endif - for (; __n > 0; ++__f, (void) --__n) - ::new ((void*)_VSTD::addressof(*__f)) value_type(__x); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - for (; __s != __f; ++__s) - __s->~value_type(); - throw; - } -#endif - return __f; -} - -#if _LIBCPP_STD_VER > 14 - -template <class _ForwardIterator> -inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 -void destroy(_ForwardIterator __first, _ForwardIterator __last) { - for (; __first != __last; ++__first) - _VSTD::destroy_at(_VSTD::addressof(*__first)); -} - -template <class _ForwardIterator, class _Size> -inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 -_ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) { - for (; __n > 0; (void)++__first, --__n) - _VSTD::destroy_at(_VSTD::addressof(*__first)); - return __first; -} - -template <class _ForwardIterator> -inline _LIBCPP_INLINE_VISIBILITY -void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) { - using _Vt = typename iterator_traits<_ForwardIterator>::value_type; - auto __idx = __first; -#ifndef _LIBCPP_NO_EXCEPTIONS - try { -#endif - for (; __idx != __last; ++__idx) - ::new ((void*)_VSTD::addressof(*__idx)) _Vt; -#ifndef _LIBCPP_NO_EXCEPTIONS - } catch (...) { - _VSTD::destroy(__first, __idx); - throw; - } -#endif -} - -template <class _ForwardIterator, class _Size> -inline _LIBCPP_INLINE_VISIBILITY -_ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) { - using _Vt = typename iterator_traits<_ForwardIterator>::value_type; - auto __idx = __first; -#ifndef _LIBCPP_NO_EXCEPTIONS - try { -#endif - for (; __n > 0; (void)++__idx, --__n) - ::new ((void*)_VSTD::addressof(*__idx)) _Vt; - return __idx; -#ifndef _LIBCPP_NO_EXCEPTIONS - } catch (...) { - _VSTD::destroy(__first, __idx); - throw; - } -#endif -} - - -template <class _ForwardIterator> -inline _LIBCPP_INLINE_VISIBILITY -void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) { - using _Vt = typename iterator_traits<_ForwardIterator>::value_type; - auto __idx = __first; -#ifndef _LIBCPP_NO_EXCEPTIONS - try { -#endif - for (; __idx != __last; ++__idx) - ::new ((void*)_VSTD::addressof(*__idx)) _Vt(); -#ifndef _LIBCPP_NO_EXCEPTIONS - } catch (...) { - _VSTD::destroy(__first, __idx); - throw; - } -#endif -} - -template <class _ForwardIterator, class _Size> -inline _LIBCPP_INLINE_VISIBILITY -_ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) { - using _Vt = typename iterator_traits<_ForwardIterator>::value_type; - auto __idx = __first; -#ifndef _LIBCPP_NO_EXCEPTIONS - try { -#endif - for (; __n > 0; (void)++__idx, --__n) - ::new ((void*)_VSTD::addressof(*__idx)) _Vt(); - return __idx; -#ifndef _LIBCPP_NO_EXCEPTIONS - } catch (...) { - _VSTD::destroy(__first, __idx); - throw; - } -#endif -} - - -template <class _InputIt, class _ForwardIt> -inline _LIBCPP_INLINE_VISIBILITY -_ForwardIt uninitialized_move(_InputIt __first, _InputIt __last, _ForwardIt __first_res) { - using _Vt = typename iterator_traits<_ForwardIt>::value_type; - auto __idx = __first_res; -#ifndef _LIBCPP_NO_EXCEPTIONS - try { -#endif - for (; __first != __last; (void)++__idx, ++__first) - ::new ((void*)_VSTD::addressof(*__idx)) _Vt(_VSTD::move(*__first)); - return __idx; -#ifndef _LIBCPP_NO_EXCEPTIONS - } catch (...) { - _VSTD::destroy(__first_res, __idx); - throw; - } -#endif -} - -template <class _InputIt, class _Size, class _ForwardIt> -inline _LIBCPP_INLINE_VISIBILITY -pair<_InputIt, _ForwardIt> -uninitialized_move_n(_InputIt __first, _Size __n, _ForwardIt __first_res) { - using _Vt = typename iterator_traits<_ForwardIt>::value_type; - auto __idx = __first_res; -#ifndef _LIBCPP_NO_EXCEPTIONS - try { -#endif - for (; __n > 0; ++__idx, (void)++__first, --__n) - ::new ((void*)_VSTD::addressof(*__idx)) _Vt(_VSTD::move(*__first)); - return {__first, __idx}; -#ifndef _LIBCPP_NO_EXCEPTIONS - } catch (...) { - _VSTD::destroy(__first_res, __idx); - throw; - } -#endif -} - - -#endif // _LIBCPP_STD_VER > 14 - -// NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively) -// should be sufficient for thread safety. -// See https://bugs.llvm.org/show_bug.cgi?id=22803 -#if defined(__clang__) && __has_builtin(__atomic_add_fetch) \ - && defined(__ATOMIC_RELAXED) \ - && defined(__ATOMIC_ACQ_REL) -# define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT -#elif defined(_LIBCPP_COMPILER_GCC) -# define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT -#endif - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY _Tp -__libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPT -{ -#if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS) - return __atomic_add_fetch(&__t, 1, __ATOMIC_RELAXED); -#else - return __t += 1; -#endif -} - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY _Tp -__libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPT -{ -#if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS) - return __atomic_add_fetch(&__t, -1, __ATOMIC_ACQ_REL); -#else - return __t -= 1; -#endif -} - -class _LIBCPP_EXCEPTION_ABI bad_weak_ptr - : public std::exception -{ -public: - bad_weak_ptr() _NOEXCEPT = default; - bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default; - virtual ~bad_weak_ptr() _NOEXCEPT; - virtual const char* what() const _NOEXCEPT; -}; - -_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY -void __throw_bad_weak_ptr() -{ -#ifndef _LIBCPP_NO_EXCEPTIONS - throw bad_weak_ptr(); -#else - _VSTD::abort(); -#endif -} - -template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr; - -class _LIBCPP_TYPE_VIS __shared_count -{ - __shared_count(const __shared_count&); - __shared_count& operator=(const __shared_count&); - -protected: - long __shared_owners_; - virtual ~__shared_count(); -private: - virtual void __on_zero_shared() _NOEXCEPT = 0; - -public: - _LIBCPP_INLINE_VISIBILITY - explicit __shared_count(long __refs = 0) _NOEXCEPT - : __shared_owners_(__refs) {} - -#if defined(_LIBCPP_BUILDING_LIBRARY) && \ - defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS) - void __add_shared() _NOEXCEPT; - bool __release_shared() _NOEXCEPT; -#else - _LIBCPP_INLINE_VISIBILITY - void __add_shared() _NOEXCEPT { - __libcpp_atomic_refcount_increment(__shared_owners_); - } - _LIBCPP_INLINE_VISIBILITY - bool __release_shared() _NOEXCEPT { - if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) { - __on_zero_shared(); - return true; - } - return false; - } -#endif - _LIBCPP_INLINE_VISIBILITY - long use_count() const _NOEXCEPT { - return __libcpp_relaxed_load(&__shared_owners_) + 1; - } -}; - -class _LIBCPP_TYPE_VIS __shared_weak_count - : private __shared_count -{ - long __shared_weak_owners_; - -public: - _LIBCPP_INLINE_VISIBILITY - explicit __shared_weak_count(long __refs = 0) _NOEXCEPT - : __shared_count(__refs), - __shared_weak_owners_(__refs) {} -protected: - virtual ~__shared_weak_count(); - -public: -#if defined(_LIBCPP_BUILDING_LIBRARY) && \ - defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS) - void __add_shared() _NOEXCEPT; - void __add_weak() _NOEXCEPT; - void __release_shared() _NOEXCEPT; -#else - _LIBCPP_INLINE_VISIBILITY - void __add_shared() _NOEXCEPT { - __shared_count::__add_shared(); - } - _LIBCPP_INLINE_VISIBILITY - void __add_weak() _NOEXCEPT { - __libcpp_atomic_refcount_increment(__shared_weak_owners_); - } - _LIBCPP_INLINE_VISIBILITY - void __release_shared() _NOEXCEPT { - if (__shared_count::__release_shared()) - __release_weak(); - } -#endif - void __release_weak() _NOEXCEPT; - _LIBCPP_INLINE_VISIBILITY - long use_count() const _NOEXCEPT {return __shared_count::use_count();} - __shared_weak_count* lock() _NOEXCEPT; - - virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; -private: - virtual void __on_zero_shared_weak() _NOEXCEPT = 0; -}; - -template <class _Tp, class _Dp, class _Alloc> -class __shared_ptr_pointer - : public __shared_weak_count -{ - __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_; -public: - _LIBCPP_INLINE_VISIBILITY - __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a) - : __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {} - -#ifndef _LIBCPP_NO_RTTI - virtual const void* __get_deleter(const type_info&) const _NOEXCEPT; -#endif - -private: - virtual void __on_zero_shared() _NOEXCEPT; - virtual void __on_zero_shared_weak() _NOEXCEPT; -}; - -#ifndef _LIBCPP_NO_RTTI - -template <class _Tp, class _Dp, class _Alloc> -const void* -__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT -{ - return __t == typeid(_Dp) ? _VSTD::addressof(__data_.first().second()) : nullptr; -} - -#endif // _LIBCPP_NO_RTTI - -template <class _Tp, class _Dp, class _Alloc> -void -__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT -{ - __data_.first().second()(__data_.first().first()); - __data_.first().second().~_Dp(); -} - -template <class _Tp, class _Dp, class _Alloc> -void -__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT -{ - typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al; - typedef allocator_traits<_Al> _ATraits; - typedef pointer_traits<typename _ATraits::pointer> _PTraits; - - _Al __a(__data_.second()); - __data_.second().~_Alloc(); - __a.deallocate(_PTraits::pointer_to(*this), 1); -} - -template <class _Tp, class _Alloc> -struct __shared_ptr_emplace - : __shared_weak_count -{ - template<class ..._Args> - _LIBCPP_HIDE_FROM_ABI - explicit __shared_ptr_emplace(_Alloc __a, _Args&& ...__args) - : __storage_(_VSTD::move(__a)) - { -#if _LIBCPP_STD_VER > 17 - using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type; - _TpAlloc __tmp(*__get_alloc()); - allocator_traits<_TpAlloc>::construct(__tmp, __get_elem(), _VSTD::forward<_Args>(__args)...); -#else - ::new ((void*)__get_elem()) _Tp(_VSTD::forward<_Args>(__args)...); -#endif - } - - _LIBCPP_HIDE_FROM_ABI - _Alloc* __get_alloc() _NOEXCEPT { return __storage_.__get_alloc(); } - - _LIBCPP_HIDE_FROM_ABI - _Tp* __get_elem() _NOEXCEPT { return __storage_.__get_elem(); } - -private: - virtual void __on_zero_shared() _NOEXCEPT { -#if _LIBCPP_STD_VER > 17 - using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type; - _TpAlloc __tmp(*__get_alloc()); - allocator_traits<_TpAlloc>::destroy(__tmp, __get_elem()); -#else - __get_elem()->~_Tp(); -#endif - } - - virtual void __on_zero_shared_weak() _NOEXCEPT { - using _ControlBlockAlloc = typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type; - using _ControlBlockPointer = typename allocator_traits<_ControlBlockAlloc>::pointer; - _ControlBlockAlloc __tmp(*__get_alloc()); - __storage_.~_Storage(); - allocator_traits<_ControlBlockAlloc>::deallocate(__tmp, - pointer_traits<_ControlBlockPointer>::pointer_to(*this), 1); - } - - // This class implements the control block for non-array shared pointers created - // through `std::allocate_shared` and `std::make_shared`. - // - // In previous versions of the library, we used a compressed pair to store - // both the _Alloc and the _Tp. This implies using EBO, which is incompatible - // with Allocator construction for _Tp. To allow implementing P0674 in C++20, - // we now use a properly aligned char buffer while making sure that we maintain - // the same layout that we had when we used a compressed pair. - using _CompressedPair = __compressed_pair<_Alloc, _Tp>; - struct _ALIGNAS_TYPE(_CompressedPair) _Storage { - char __blob_[sizeof(_CompressedPair)]; - - _LIBCPP_HIDE_FROM_ABI explicit _Storage(_Alloc&& __a) { - ::new ((void*)__get_alloc()) _Alloc(_VSTD::move(__a)); - } - _LIBCPP_HIDE_FROM_ABI ~_Storage() { - __get_alloc()->~_Alloc(); - } - _Alloc* __get_alloc() _NOEXCEPT { - _CompressedPair *__as_pair = reinterpret_cast<_CompressedPair*>(__blob_); - typename _CompressedPair::_Base1* __first = _CompressedPair::__get_first_base(__as_pair); - _Alloc *__alloc = reinterpret_cast<_Alloc*>(__first); - return __alloc; - } - _Tp* __get_elem() _NOEXCEPT { - _CompressedPair *__as_pair = reinterpret_cast<_CompressedPair*>(__blob_); - typename _CompressedPair::_Base2* __second = _CompressedPair::__get_second_base(__as_pair); - _Tp *__elem = reinterpret_cast<_Tp*>(__second); - return __elem; - } - }; - - static_assert(_LIBCPP_ALIGNOF(_Storage) == _LIBCPP_ALIGNOF(_CompressedPair), ""); - static_assert(sizeof(_Storage) == sizeof(_CompressedPair), ""); - _Storage __storage_; -}; - -struct __shared_ptr_dummy_rebind_allocator_type; -template <> -class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type> -{ -public: - template <class _Other> - struct rebind - { - typedef allocator<_Other> other; - }; -}; - -template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this; - -template<class _Tp, class _Up> -struct __compatible_with -#if _LIBCPP_STD_VER > 14 - : is_convertible<remove_extent_t<_Tp>*, remove_extent_t<_Up>*> {}; -#else - : is_convertible<_Tp*, _Up*> {}; -#endif // _LIBCPP_STD_VER > 14 - -#if defined(_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI) -# define _LIBCPP_SHARED_PTR_TRIVIAL_ABI __attribute__((trivial_abi)) -#else -# define _LIBCPP_SHARED_PTR_TRIVIAL_ABI -#endif - -template<class _Tp> -class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS shared_ptr -{ -public: -#if _LIBCPP_STD_VER > 14 - typedef weak_ptr<_Tp> weak_type; - typedef remove_extent_t<_Tp> element_type; -#else - typedef _Tp element_type; -#endif - -private: - element_type* __ptr_; - __shared_weak_count* __cntrl_; - - struct __nat {int __for_bool_;}; -public: - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR shared_ptr() _NOEXCEPT; - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT; - template<class _Yp> - explicit shared_ptr(_Yp* __p, - typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat()); - template<class _Yp, class _Dp> - shared_ptr(_Yp* __p, _Dp __d, - typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat()); - template<class _Yp, class _Dp, class _Alloc> - shared_ptr(_Yp* __p, _Dp __d, _Alloc __a, - typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat()); - template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d); - template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a); - template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT; - _LIBCPP_INLINE_VISIBILITY - shared_ptr(const shared_ptr& __r) _NOEXCEPT; - template<class _Yp> - _LIBCPP_INLINE_VISIBILITY - shared_ptr(const shared_ptr<_Yp>& __r, - typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat()) - _NOEXCEPT; - _LIBCPP_INLINE_VISIBILITY - shared_ptr(shared_ptr&& __r) _NOEXCEPT; - template<class _Yp> _LIBCPP_INLINE_VISIBILITY shared_ptr(shared_ptr<_Yp>&& __r, - typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat()) - _NOEXCEPT; - template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r, - typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type= __nat()); -#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) - template<class _Yp> - shared_ptr(auto_ptr<_Yp>&& __r, - typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat()); -#endif - template <class _Yp, class _Dp> - shared_ptr(unique_ptr<_Yp, _Dp>&&, - typename enable_if - < - !is_lvalue_reference<_Dp>::value && - !is_array<_Yp>::value && - is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, - __nat - >::type = __nat()); - template <class _Yp, class _Dp> - shared_ptr(unique_ptr<_Yp, _Dp>&&, - typename enable_if - < - is_lvalue_reference<_Dp>::value && - !is_array<_Yp>::value && - is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, - __nat - >::type = __nat()); - - ~shared_ptr(); - - _LIBCPP_INLINE_VISIBILITY - shared_ptr& operator=(const shared_ptr& __r) _NOEXCEPT; - template<class _Yp> - typename enable_if - < - __compatible_with<_Yp, element_type>::value, - shared_ptr& - >::type - _LIBCPP_INLINE_VISIBILITY - operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT; - _LIBCPP_INLINE_VISIBILITY - shared_ptr& operator=(shared_ptr&& __r) _NOEXCEPT; - template<class _Yp> - typename enable_if - < - __compatible_with<_Yp, element_type>::value, - shared_ptr& - >::type - _LIBCPP_INLINE_VISIBILITY - operator=(shared_ptr<_Yp>&& __r); -#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) - template<class _Yp> - _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - !is_array<_Yp>::value && - is_convertible<_Yp*, element_type*>::value, - shared_ptr - >::type& - operator=(auto_ptr<_Yp>&& __r); -#endif - template <class _Yp, class _Dp> - typename enable_if - < - !is_array<_Yp>::value && - is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, - shared_ptr& - >::type - _LIBCPP_INLINE_VISIBILITY - operator=(unique_ptr<_Yp, _Dp>&& __r); - - _LIBCPP_INLINE_VISIBILITY - void swap(shared_ptr& __r) _NOEXCEPT; - _LIBCPP_INLINE_VISIBILITY - void reset() _NOEXCEPT; - template<class _Yp> - typename enable_if - < - __compatible_with<_Yp, element_type>::value, - void - >::type - _LIBCPP_INLINE_VISIBILITY - reset(_Yp* __p); - template<class _Yp, class _Dp> - typename enable_if - < - __compatible_with<_Yp, element_type>::value, - void - >::type - _LIBCPP_INLINE_VISIBILITY - reset(_Yp* __p, _Dp __d); - template<class _Yp, class _Dp, class _Alloc> - typename enable_if - < - __compatible_with<_Yp, element_type>::value, - void - >::type - _LIBCPP_INLINE_VISIBILITY - reset(_Yp* __p, _Dp __d, _Alloc __a); - - _LIBCPP_INLINE_VISIBILITY - element_type* get() const _NOEXCEPT {return __ptr_;} - _LIBCPP_INLINE_VISIBILITY - typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPT - {return *__ptr_;} - _LIBCPP_INLINE_VISIBILITY - element_type* operator->() const _NOEXCEPT - { - static_assert(!_VSTD::is_array<_Tp>::value, - "std::shared_ptr<T>::operator-> is only valid when T is not an array type."); - return __ptr_; - } - _LIBCPP_INLINE_VISIBILITY - long use_count() const _NOEXCEPT {return __cntrl_ ? __cntrl_->use_count() : 0;} - _LIBCPP_INLINE_VISIBILITY - bool unique() const _NOEXCEPT {return use_count() == 1;} - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return get() != nullptr;} - template <class _Up> - _LIBCPP_INLINE_VISIBILITY - bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPT - {return __cntrl_ < __p.__cntrl_;} - template <class _Up> - _LIBCPP_INLINE_VISIBILITY - bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPT - {return __cntrl_ < __p.__cntrl_;} - _LIBCPP_INLINE_VISIBILITY - bool - __owner_equivalent(const shared_ptr& __p) const - {return __cntrl_ == __p.__cntrl_;} - -#if _LIBCPP_STD_VER > 14 - typename add_lvalue_reference<element_type>::type - _LIBCPP_INLINE_VISIBILITY - operator[](ptrdiff_t __i) const - { - static_assert(_VSTD::is_array<_Tp>::value, - "std::shared_ptr<T>::operator[] is only valid when T is an array type."); - return __ptr_[__i]; - } -#endif - -#ifndef _LIBCPP_NO_RTTI - template <class _Dp> - _LIBCPP_INLINE_VISIBILITY - _Dp* __get_deleter() const _NOEXCEPT - {return static_cast<_Dp*>(__cntrl_ - ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp))) - : nullptr);} -#endif // _LIBCPP_NO_RTTI - - template<class _Yp, class _CntrlBlk> - static shared_ptr<_Tp> - __create_with_control_block(_Yp* __p, _CntrlBlk* __cntrl) _NOEXCEPT - { - shared_ptr<_Tp> __r; - __r.__ptr_ = __p; - __r.__cntrl_ = __cntrl; - __r.__enable_weak_this(__r.__ptr_, __r.__ptr_); - return __r; - } - -private: - template <class _Yp, bool = is_function<_Yp>::value> - struct __shared_ptr_default_allocator - { - typedef allocator<_Yp> type; - }; - - template <class _Yp> - struct __shared_ptr_default_allocator<_Yp, true> - { - typedef allocator<__shared_ptr_dummy_rebind_allocator_type> type; - }; - - template <class _Yp, class _OrigPtr> - _LIBCPP_INLINE_VISIBILITY - typename enable_if<is_convertible<_OrigPtr*, - const enable_shared_from_this<_Yp>* - >::value, - void>::type - __enable_weak_this(const enable_shared_from_this<_Yp>* __e, - _OrigPtr* __ptr) _NOEXCEPT - { - typedef typename remove_cv<_Yp>::type _RawYp; - if (__e && __e->__weak_this_.expired()) - { - __e->__weak_this_ = shared_ptr<_RawYp>(*this, - const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr))); - } - } - - _LIBCPP_INLINE_VISIBILITY void __enable_weak_this(...) _NOEXCEPT {} - - template <class, class _Yp> - struct __shared_ptr_default_delete - : default_delete<_Yp> {}; - - template <class _Yp, class _Un, size_t _Sz> - struct __shared_ptr_default_delete<_Yp[_Sz], _Un> - : default_delete<_Yp[]> {}; - - template <class _Yp, class _Un> - struct __shared_ptr_default_delete<_Yp[], _Un> - : default_delete<_Yp[]> {}; - - template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr; - template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr; -}; - -#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES -template<class _Tp> -shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>; -template<class _Tp, class _Dp> -shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>; -#endif - -template<class _Tp> -inline -_LIBCPP_CONSTEXPR -shared_ptr<_Tp>::shared_ptr() _NOEXCEPT - : __ptr_(nullptr), - __cntrl_(nullptr) -{ -} - -template<class _Tp> -inline -_LIBCPP_CONSTEXPR -shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPT - : __ptr_(nullptr), - __cntrl_(nullptr) -{ -} - -template<class _Tp> -template<class _Yp> -shared_ptr<_Tp>::shared_ptr(_Yp* __p, - typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type) - : __ptr_(__p) -{ - unique_ptr<_Yp> __hold(__p); - typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; - typedef __shared_ptr_pointer<_Yp*, __shared_ptr_default_delete<_Tp, _Yp>, _AllocT > _CntrlBlk; - __cntrl_ = new _CntrlBlk(__p, __shared_ptr_default_delete<_Tp, _Yp>(), _AllocT()); - __hold.release(); - __enable_weak_this(__p, __p); -} - -template<class _Tp> -template<class _Yp, class _Dp> -shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, - typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type) - : __ptr_(__p) -{ -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; - typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk; - __cntrl_ = new _CntrlBlk(__p, __d, _AllocT()); - __enable_weak_this(__p, __p); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __d(__p); - throw; - } -#endif // _LIBCPP_NO_EXCEPTIONS -} - -template<class _Tp> -template<class _Dp> -shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d) - : __ptr_(nullptr) -{ -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT; - typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT > _CntrlBlk; - __cntrl_ = new _CntrlBlk(__p, __d, _AllocT()); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __d(__p); - throw; - } -#endif // _LIBCPP_NO_EXCEPTIONS -} - -template<class _Tp> -template<class _Yp, class _Dp, class _Alloc> -shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a, - typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type) - : __ptr_(__p) -{ -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk; - typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2; - typedef __allocator_destructor<_A2> _D2; - _A2 __a2(__a); - unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); - ::new ((void*)_VSTD::addressof(*__hold2.get())) _CntrlBlk(__p, __d, __a); - __cntrl_ = _VSTD::addressof(*__hold2.release()); - __enable_weak_this(__p, __p); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __d(__p); - throw; - } -#endif // _LIBCPP_NO_EXCEPTIONS -} - -template<class _Tp> -template<class _Dp, class _Alloc> -shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a) - : __ptr_(nullptr) -{ -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk; - typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2; - typedef __allocator_destructor<_A2> _D2; - _A2 __a2(__a); - unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); - ::new ((void*)_VSTD::addressof(*__hold2.get())) _CntrlBlk(__p, __d, __a); - __cntrl_ = _VSTD::addressof(*__hold2.release()); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __d(__p); - throw; - } -#endif // _LIBCPP_NO_EXCEPTIONS -} - -template<class _Tp> -template<class _Yp> -inline -shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPT - : __ptr_(__p), - __cntrl_(__r.__cntrl_) -{ - if (__cntrl_) - __cntrl_->__add_shared(); -} - -template<class _Tp> -inline -shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPT - : __ptr_(__r.__ptr_), - __cntrl_(__r.__cntrl_) -{ - if (__cntrl_) - __cntrl_->__add_shared(); -} - -template<class _Tp> -template<class _Yp> -inline -shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, - typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type) - _NOEXCEPT - : __ptr_(__r.__ptr_), - __cntrl_(__r.__cntrl_) -{ - if (__cntrl_) - __cntrl_->__add_shared(); -} - -template<class _Tp> -inline -shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPT - : __ptr_(__r.__ptr_), - __cntrl_(__r.__cntrl_) -{ - __r.__ptr_ = nullptr; - __r.__cntrl_ = nullptr; -} - -template<class _Tp> -template<class _Yp> -inline -shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r, - typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type) - _NOEXCEPT - : __ptr_(__r.__ptr_), - __cntrl_(__r.__cntrl_) -{ - __r.__ptr_ = nullptr; - __r.__cntrl_ = nullptr; -} - -#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) -template<class _Tp> -template<class _Yp> -shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp>&& __r, - typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) - : __ptr_(__r.get()) -{ - typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk; - __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>()); - __enable_weak_this(__r.get(), __r.get()); - __r.release(); -} -#endif - -template<class _Tp> -template <class _Yp, class _Dp> -shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r, - typename enable_if - < - !is_lvalue_reference<_Dp>::value && - !is_array<_Yp>::value && - is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, - __nat - >::type) - : __ptr_(__r.get()) -{ -#if _LIBCPP_STD_VER > 11 - if (__ptr_ == nullptr) - __cntrl_ = nullptr; - else -#endif - { - typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; - typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk; - __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), _AllocT()); - __enable_weak_this(__r.get(), __r.get()); - } - __r.release(); -} - -template<class _Tp> -template <class _Yp, class _Dp> -shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r, - typename enable_if - < - is_lvalue_reference<_Dp>::value && - !is_array<_Yp>::value && - is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value, - __nat - >::type) - : __ptr_(__r.get()) -{ -#if _LIBCPP_STD_VER > 11 - if (__ptr_ == nullptr) - __cntrl_ = nullptr; - else -#endif - { - typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; - typedef __shared_ptr_pointer<_Yp*, - reference_wrapper<typename remove_reference<_Dp>::type>, - _AllocT > _CntrlBlk; - __cntrl_ = new _CntrlBlk(__r.get(), _VSTD::ref(__r.get_deleter()), _AllocT()); - __enable_weak_this(__r.get(), __r.get()); - } - __r.release(); -} - -template<class _Tp> -shared_ptr<_Tp>::~shared_ptr() -{ - if (__cntrl_) - __cntrl_->__release_shared(); -} - -template<class _Tp> -inline -shared_ptr<_Tp>& -shared_ptr<_Tp>::operator=(const shared_ptr& __r) _NOEXCEPT -{ - shared_ptr(__r).swap(*this); - return *this; -} - -template<class _Tp> -template<class _Yp> -inline -typename enable_if -< - __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value, - shared_ptr<_Tp>& ->::type -shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT -{ - shared_ptr(__r).swap(*this); - return *this; -} - -template<class _Tp> -inline -shared_ptr<_Tp>& -shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT -{ - shared_ptr(_VSTD::move(__r)).swap(*this); - return *this; -} - -template<class _Tp> -template<class _Yp> -inline -typename enable_if -< - __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value, - shared_ptr<_Tp>& ->::type -shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r) -{ - shared_ptr(_VSTD::move(__r)).swap(*this); - return *this; -} - -#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR) -template<class _Tp> -template<class _Yp> -inline -typename enable_if -< - !is_array<_Yp>::value && - is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value, - shared_ptr<_Tp> ->::type& -shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r) -{ - shared_ptr(_VSTD::move(__r)).swap(*this); - return *this; -} -#endif - -template<class _Tp> -template <class _Yp, class _Dp> -inline -typename enable_if -< - !is_array<_Yp>::value && - is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, - typename shared_ptr<_Tp>::element_type*>::value, - shared_ptr<_Tp>& ->::type -shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r) -{ - shared_ptr(_VSTD::move(__r)).swap(*this); - return *this; -} - -template<class _Tp> -inline -void -shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPT -{ - _VSTD::swap(__ptr_, __r.__ptr_); - _VSTD::swap(__cntrl_, __r.__cntrl_); -} - -template<class _Tp> -inline -void -shared_ptr<_Tp>::reset() _NOEXCEPT -{ - shared_ptr().swap(*this); -} - -template<class _Tp> -template<class _Yp> -inline -typename enable_if -< - __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value, - void ->::type -shared_ptr<_Tp>::reset(_Yp* __p) -{ - shared_ptr(__p).swap(*this); -} - -template<class _Tp> -template<class _Yp, class _Dp> -inline -typename enable_if -< - __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value, - void ->::type -shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d) -{ - shared_ptr(__p, __d).swap(*this); -} - -template<class _Tp> -template<class _Yp, class _Dp, class _Alloc> -inline -typename enable_if -< - __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value, - void ->::type -shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a) -{ - shared_ptr(__p, __d, __a).swap(*this); -} - -// -// std::allocate_shared and std::make_shared -// -template<class _Tp, class _Alloc, class ..._Args, class = _EnableIf<!is_array<_Tp>::value> > -_LIBCPP_HIDE_FROM_ABI -shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&& ...__args) -{ - using _ControlBlock = __shared_ptr_emplace<_Tp, _Alloc>; - using _ControlBlockAllocator = typename __allocator_traits_rebind<_Alloc, _ControlBlock>::type; - __allocation_guard<_ControlBlockAllocator> __guard(__a, 1); - ::new ((void*)_VSTD::addressof(*__guard.__get())) _ControlBlock(__a, _VSTD::forward<_Args>(__args)...); - auto __control_block = __guard.__release_ptr(); - return shared_ptr<_Tp>::__create_with_control_block((*__control_block).__get_elem(), _VSTD::addressof(*__control_block)); -} - -template<class _Tp, class ..._Args, class = _EnableIf<!is_array<_Tp>::value> > -_LIBCPP_HIDE_FROM_ABI -shared_ptr<_Tp> make_shared(_Args&& ...__args) -{ - return _VSTD::allocate_shared<_Tp>(allocator<_Tp>(), _VSTD::forward<_Args>(__args)...); -} - -template<class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT -{ - return __x.get() == __y.get(); -} - -template<class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT -{ - return !(__x == __y); -} - -template<class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT -{ -#if _LIBCPP_STD_VER <= 11 - typedef typename common_type<_Tp*, _Up*>::type _Vp; - return less<_Vp>()(__x.get(), __y.get()); -#else - return less<>()(__x.get(), __y.get()); -#endif - -} - -template<class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT -{ - return __y < __x; -} - -template<class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT -{ - return !(__y < __x); -} - -template<class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT -{ - return !(__x < __y); -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT -{ - return !__x; -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT -{ - return !__x; -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT -{ - return static_cast<bool>(__x); -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT -{ - return static_cast<bool>(__x); -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT -{ - return less<_Tp*>()(__x.get(), nullptr); -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT -{ - return less<_Tp*>()(nullptr, __x.get()); -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT -{ - return nullptr < __x; -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT -{ - return __x < nullptr; -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT -{ - return !(nullptr < __x); -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT -{ - return !(__x < nullptr); -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT -{ - return !(__x < nullptr); -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT -{ - return !(nullptr < __x); -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -void -swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT -{ - __x.swap(__y); -} - -template<class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY -shared_ptr<_Tp> -static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT -{ - return shared_ptr<_Tp>(__r, - static_cast< - typename shared_ptr<_Tp>::element_type*>(__r.get())); -} - -template<class _Tp, class _Up> -inline _LIBCPP_INLINE_VISIBILITY -shared_ptr<_Tp> -dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT -{ - typedef typename shared_ptr<_Tp>::element_type _ET; - _ET* __p = dynamic_cast<_ET*>(__r.get()); - return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>(); -} - -template<class _Tp, class _Up> -shared_ptr<_Tp> -const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT -{ - typedef typename shared_ptr<_Tp>::element_type _RTp; - return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get())); -} - -template<class _Tp, class _Up> -shared_ptr<_Tp> -reinterpret_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT -{ - return shared_ptr<_Tp>(__r, - reinterpret_cast< - typename shared_ptr<_Tp>::element_type*>(__r.get())); -} - -#ifndef _LIBCPP_NO_RTTI - -template<class _Dp, class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -_Dp* -get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT -{ - return __p.template __get_deleter<_Dp>(); -} - -#endif // _LIBCPP_NO_RTTI - -template<class _Tp> -class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS weak_ptr -{ -public: - typedef _Tp element_type; -private: - element_type* __ptr_; - __shared_weak_count* __cntrl_; - -public: - _LIBCPP_INLINE_VISIBILITY - _LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT; - template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(shared_ptr<_Yp> const& __r, - typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) - _NOEXCEPT; - _LIBCPP_INLINE_VISIBILITY - weak_ptr(weak_ptr const& __r) _NOEXCEPT; - template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp> const& __r, - typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) - _NOEXCEPT; - - _LIBCPP_INLINE_VISIBILITY - weak_ptr(weak_ptr&& __r) _NOEXCEPT; - template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r, - typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0) - _NOEXCEPT; - ~weak_ptr(); - - _LIBCPP_INLINE_VISIBILITY - weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT; - template<class _Yp> - typename enable_if - < - is_convertible<_Yp*, element_type*>::value, - weak_ptr& - >::type - _LIBCPP_INLINE_VISIBILITY - operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT; - - _LIBCPP_INLINE_VISIBILITY - weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT; - template<class _Yp> - typename enable_if - < - is_convertible<_Yp*, element_type*>::value, - weak_ptr& - >::type - _LIBCPP_INLINE_VISIBILITY - operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT; - - template<class _Yp> - typename enable_if - < - is_convertible<_Yp*, element_type*>::value, - weak_ptr& - >::type - _LIBCPP_INLINE_VISIBILITY - operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT; - - _LIBCPP_INLINE_VISIBILITY - void swap(weak_ptr& __r) _NOEXCEPT; - _LIBCPP_INLINE_VISIBILITY - void reset() _NOEXCEPT; - - _LIBCPP_INLINE_VISIBILITY - long use_count() const _NOEXCEPT - {return __cntrl_ ? __cntrl_->use_count() : 0;} - _LIBCPP_INLINE_VISIBILITY - bool expired() const _NOEXCEPT - {return __cntrl_ == nullptr || __cntrl_->use_count() == 0;} - shared_ptr<_Tp> lock() const _NOEXCEPT; - template<class _Up> - _LIBCPP_INLINE_VISIBILITY - bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT - {return __cntrl_ < __r.__cntrl_;} - template<class _Up> - _LIBCPP_INLINE_VISIBILITY - bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT - {return __cntrl_ < __r.__cntrl_;} - - template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr; - template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr; -}; - -#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES -template<class _Tp> -weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>; -#endif - -template<class _Tp> -inline -_LIBCPP_CONSTEXPR -weak_ptr<_Tp>::weak_ptr() _NOEXCEPT - : __ptr_(nullptr), - __cntrl_(nullptr) -{ -} - -template<class _Tp> -inline -weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT - : __ptr_(__r.__ptr_), - __cntrl_(__r.__cntrl_) -{ - if (__cntrl_) - __cntrl_->__add_weak(); -} - -template<class _Tp> -template<class _Yp> -inline -weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r, - typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) - _NOEXCEPT - : __ptr_(__r.__ptr_), - __cntrl_(__r.__cntrl_) -{ - if (__cntrl_) - __cntrl_->__add_weak(); -} - -template<class _Tp> -template<class _Yp> -inline -weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r, - typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) - _NOEXCEPT - : __ptr_(__r.__ptr_), - __cntrl_(__r.__cntrl_) -{ - if (__cntrl_) - __cntrl_->__add_weak(); -} - -template<class _Tp> -inline -weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT - : __ptr_(__r.__ptr_), - __cntrl_(__r.__cntrl_) -{ - __r.__ptr_ = nullptr; - __r.__cntrl_ = nullptr; -} - -template<class _Tp> -template<class _Yp> -inline -weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r, - typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type) - _NOEXCEPT - : __ptr_(__r.__ptr_), - __cntrl_(__r.__cntrl_) -{ - __r.__ptr_ = nullptr; - __r.__cntrl_ = nullptr; -} - -template<class _Tp> -weak_ptr<_Tp>::~weak_ptr() -{ - if (__cntrl_) - __cntrl_->__release_weak(); -} - -template<class _Tp> -inline -weak_ptr<_Tp>& -weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT -{ - weak_ptr(__r).swap(*this); - return *this; -} - -template<class _Tp> -template<class _Yp> -inline -typename enable_if -< - is_convertible<_Yp*, _Tp*>::value, - weak_ptr<_Tp>& ->::type -weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT -{ - weak_ptr(__r).swap(*this); - return *this; -} - -template<class _Tp> -inline -weak_ptr<_Tp>& -weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT -{ - weak_ptr(_VSTD::move(__r)).swap(*this); - return *this; -} - -template<class _Tp> -template<class _Yp> -inline -typename enable_if -< - is_convertible<_Yp*, _Tp*>::value, - weak_ptr<_Tp>& ->::type -weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT -{ - weak_ptr(_VSTD::move(__r)).swap(*this); - return *this; -} - -template<class _Tp> -template<class _Yp> -inline -typename enable_if -< - is_convertible<_Yp*, _Tp*>::value, - weak_ptr<_Tp>& ->::type -weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT -{ - weak_ptr(__r).swap(*this); - return *this; -} - -template<class _Tp> -inline -void -weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT -{ - _VSTD::swap(__ptr_, __r.__ptr_); - _VSTD::swap(__cntrl_, __r.__cntrl_); -} - -template<class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -void -swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT -{ - __x.swap(__y); -} - -template<class _Tp> -inline -void -weak_ptr<_Tp>::reset() _NOEXCEPT -{ - weak_ptr().swap(*this); -} - -template<class _Tp> -template<class _Yp> -shared_ptr<_Tp>::shared_ptr(const weak_ptr<_Yp>& __r, - typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type) - : __ptr_(__r.__ptr_), - __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_) -{ - if (__cntrl_ == nullptr) - __throw_bad_weak_ptr(); -} - -template<class _Tp> -shared_ptr<_Tp> -weak_ptr<_Tp>::lock() const _NOEXCEPT -{ - shared_ptr<_Tp> __r; - __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_; - if (__r.__cntrl_) - __r.__ptr_ = __ptr_; - return __r; -} - -#if _LIBCPP_STD_VER > 14 -template <class _Tp = void> struct owner_less; -#else -template <class _Tp> struct owner_less; -#endif - -template <class _Tp> -struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> > - : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool> -{ - typedef bool result_type; - _LIBCPP_INLINE_VISIBILITY - bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT - {return __x.owner_before(__y);} - _LIBCPP_INLINE_VISIBILITY - bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT - {return __x.owner_before(__y);} - _LIBCPP_INLINE_VISIBILITY - bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT - {return __x.owner_before(__y);} -}; - -template <class _Tp> -struct _LIBCPP_TEMPLATE_VIS owner_less<weak_ptr<_Tp> > - : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool> -{ - typedef bool result_type; - _LIBCPP_INLINE_VISIBILITY - bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT - {return __x.owner_before(__y);} - _LIBCPP_INLINE_VISIBILITY - bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT - {return __x.owner_before(__y);} - _LIBCPP_INLINE_VISIBILITY - bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT - {return __x.owner_before(__y);} -}; - -#if _LIBCPP_STD_VER > 14 -template <> -struct _LIBCPP_TEMPLATE_VIS owner_less<void> -{ - template <class _Tp, class _Up> - _LIBCPP_INLINE_VISIBILITY - bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT - {return __x.owner_before(__y);} - template <class _Tp, class _Up> - _LIBCPP_INLINE_VISIBILITY - bool operator()( shared_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT - {return __x.owner_before(__y);} - template <class _Tp, class _Up> - _LIBCPP_INLINE_VISIBILITY - bool operator()( weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT - {return __x.owner_before(__y);} - template <class _Tp, class _Up> - _LIBCPP_INLINE_VISIBILITY - bool operator()( weak_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT - {return __x.owner_before(__y);} - typedef void is_transparent; -}; -#endif - -template<class _Tp> -class _LIBCPP_TEMPLATE_VIS enable_shared_from_this -{ - mutable weak_ptr<_Tp> __weak_this_; -protected: - _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR - enable_shared_from_this() _NOEXCEPT {} - _LIBCPP_INLINE_VISIBILITY - enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {} - _LIBCPP_INLINE_VISIBILITY - enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPT - {return *this;} - _LIBCPP_INLINE_VISIBILITY - ~enable_shared_from_this() {} -public: - _LIBCPP_INLINE_VISIBILITY - shared_ptr<_Tp> shared_from_this() - {return shared_ptr<_Tp>(__weak_this_);} - _LIBCPP_INLINE_VISIBILITY - shared_ptr<_Tp const> shared_from_this() const - {return shared_ptr<const _Tp>(__weak_this_);} - -#if _LIBCPP_STD_VER > 14 - _LIBCPP_INLINE_VISIBILITY - weak_ptr<_Tp> weak_from_this() _NOEXCEPT - { return __weak_this_; } - - _LIBCPP_INLINE_VISIBILITY - weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT - { return __weak_this_; } -#endif // _LIBCPP_STD_VER > 14 - - template <class _Up> friend class shared_ptr; -}; - -template <class _Tp> -struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> > -{ - typedef shared_ptr<_Tp> argument_type; - typedef size_t result_type; - - _LIBCPP_INLINE_VISIBILITY - result_type operator()(const argument_type& __ptr) const _NOEXCEPT - { - return hash<typename shared_ptr<_Tp>::element_type*>()(__ptr.get()); - } -}; - -template<class _CharT, class _Traits, class _Yp> -inline _LIBCPP_INLINE_VISIBILITY -basic_ostream<_CharT, _Traits>& -operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p); - - -#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER) - -class _LIBCPP_TYPE_VIS __sp_mut -{ - void* __lx; -public: - void lock() _NOEXCEPT; - void unlock() _NOEXCEPT; - -private: - _LIBCPP_CONSTEXPR __sp_mut(void*) _NOEXCEPT; - __sp_mut(const __sp_mut&); - __sp_mut& operator=(const __sp_mut&); - - friend _LIBCPP_FUNC_VIS __sp_mut& __get_sp_mut(const void*); -}; - -_LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR -__sp_mut& __get_sp_mut(const void*); - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -bool -atomic_is_lock_free(const shared_ptr<_Tp>*) -{ - return false; -} - -template <class _Tp> -_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR -shared_ptr<_Tp> -atomic_load(const shared_ptr<_Tp>* __p) -{ - __sp_mut& __m = __get_sp_mut(__p); - __m.lock(); - shared_ptr<_Tp> __q = *__p; - __m.unlock(); - return __q; -} - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR -shared_ptr<_Tp> -atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) -{ - return atomic_load(__p); -} - -template <class _Tp> -_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR -void -atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) -{ - __sp_mut& __m = __get_sp_mut(__p); - __m.lock(); - __p->swap(__r); - __m.unlock(); -} - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR -void -atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) -{ - atomic_store(__p, __r); -} - -template <class _Tp> -_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR -shared_ptr<_Tp> -atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) -{ - __sp_mut& __m = __get_sp_mut(__p); - __m.lock(); - __p->swap(__r); - __m.unlock(); - return __r; -} - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR -shared_ptr<_Tp> -atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) -{ - return atomic_exchange(__p, __r); -} - -template <class _Tp> -_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR -bool -atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) -{ - shared_ptr<_Tp> __temp; - __sp_mut& __m = __get_sp_mut(__p); - __m.lock(); - if (__p->__owner_equivalent(*__v)) - { - _VSTD::swap(__temp, *__p); - *__p = __w; - __m.unlock(); - return true; - } - _VSTD::swap(__temp, *__v); - *__v = *__p; - __m.unlock(); - return false; -} - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR -bool -atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) -{ - return atomic_compare_exchange_strong(__p, __v, __w); -} - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR -bool -atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, - shared_ptr<_Tp> __w, memory_order, memory_order) -{ - return atomic_compare_exchange_strong(__p, __v, __w); -} - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR -bool -atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, - shared_ptr<_Tp> __w, memory_order, memory_order) -{ - return atomic_compare_exchange_weak(__p, __v, __w); -} - -#endif // !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER) - -//enum class -#if defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) -# ifndef _LIBCPP_CXX03_LANG -enum class pointer_safety : unsigned char { - relaxed, - preferred, - strict -}; -# endif -#else -struct _LIBCPP_TYPE_VIS pointer_safety -{ - enum __lx - { - relaxed, - preferred, - strict - }; - - __lx __v_; - - _LIBCPP_INLINE_VISIBILITY - pointer_safety() : __v_() {} - - _LIBCPP_INLINE_VISIBILITY - pointer_safety(__lx __v) : __v_(__v) {} - _LIBCPP_INLINE_VISIBILITY - operator int() const {return __v_;} -}; -#endif - -#if !defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) && \ - defined(_LIBCPP_BUILDING_LIBRARY) -_LIBCPP_FUNC_VIS pointer_safety get_pointer_safety() _NOEXCEPT; -#else -// This function is only offered in C++03 under ABI v1. -# if !defined(_LIBCPP_ABI_POINTER_SAFETY_ENUM_TYPE) || !defined(_LIBCPP_CXX03_LANG) -inline _LIBCPP_INLINE_VISIBILITY -pointer_safety get_pointer_safety() _NOEXCEPT { - return pointer_safety::relaxed; -} -# endif -#endif - - -_LIBCPP_FUNC_VIS void declare_reachable(void* __p); -_LIBCPP_FUNC_VIS void declare_no_pointers(char* __p, size_t __n); -_LIBCPP_FUNC_VIS void undeclare_no_pointers(char* __p, size_t __n); -_LIBCPP_FUNC_VIS void* __undeclare_reachable(void* __p); - -template <class _Tp> -inline _LIBCPP_INLINE_VISIBILITY -_Tp* -undeclare_reachable(_Tp* __p) -{ - return static_cast<_Tp*>(__undeclare_reachable(__p)); -} - _LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space); // --- Helper for container swap -- @@ -4193,7 +868,7 @@ void __swap_allocator(_Alloc & __a1, _Alloc & __a2) #endif { _VSTD::__swap_allocator(__a1, __a2, - integral_constant<bool, _VSTD::allocator_traits<_Alloc>::propagate_on_container_swap::value>()); + integral_constant<bool, allocator_traits<_Alloc>::propagate_on_container_swap::value>()); } template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> > @@ -4233,7 +908,7 @@ struct __is_allocator : false_type {}; template<typename _Alloc> struct __is_allocator<_Alloc, typename __void_t<typename _Alloc::value_type>::type, - typename __void_t<decltype(_VSTD::declval<_Alloc&>().allocate(size_t(0)))>::type + typename __void_t<decltype(declval<_Alloc&>().allocate(size_t(0)))>::type > : true_type {}; @@ -4291,4 +966,4 @@ _LIBCPP_POP_MACROS # include <__pstl_memory> #endif -#endif // _LIBCPP_MEMORY +#endif // _LIBCPP_MEMORY |