diff options
Diffstat (limited to 'system/include/libcxx/memory')
| -rw-r--r-- | system/include/libcxx/memory | 1702 |
1 files changed, 1473 insertions, 229 deletions
diff --git a/system/include/libcxx/memory b/system/include/libcxx/memory index d272c08c..4e1f7046 100644 --- a/system/include/libcxx/memory +++ b/system/include/libcxx/memory @@ -596,19 +596,23 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space); #include <iterator> #include <__functional_base> #include <iosfwd> +#include <tuple> +#include <cstring> #if defined(_LIBCPP_NO_EXCEPTIONS) #include <cassert> #endif -#pragma GCC system_header - -_LIBCPP_BEGIN_NAMESPACE_STD +#if __has_feature(cxx_atomic) +# include <atomic> +#endif -// allocator_arg_t +#include <__undef_min_max> -struct _LIBCPP_VISIBLE allocator_arg_t { }; +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif -extern const allocator_arg_t allocator_arg; +_LIBCPP_BEGIN_NAMESPACE_STD // addressof @@ -673,13 +677,24 @@ public: template <class _Up> struct rebind {typedef allocator<_Up> other;}; }; +template <> +class _LIBCPP_VISIBLE 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;}; +}; + // pointer_traits template <class _Tp> struct __has_element_type { private: - struct __two {char _; char __;}; + struct __two {char __lx; char __lxx;}; template <class _Up> static __two __test(...); template <class _Up> static char __test(typename _Up::element_type* = 0); public: @@ -767,7 +782,7 @@ template <class _Tp> struct __has_difference_type { private: - struct __two {char _; char __;}; + struct __two {char __lx; char __lxx;}; template <class _Up> static __two __test(...); template <class _Up> static char __test(typename _Up::difference_type* = 0); public: @@ -790,7 +805,7 @@ template <class _Tp, class _Up> struct __has_rebind { private: - struct __two {char _; char __;}; + struct __two {char __lx; char __lxx;}; template <class _Xp> static __two __test(...); template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0); public: @@ -983,7 +998,7 @@ template <class _Tp> struct __has_const_pointer { private: - struct __two {char _; char __;}; + struct __two {char __lx; char __lxx;}; template <class _Up> static __two __test(...); template <class _Up> static char __test(typename _Up::const_pointer* = 0); public: @@ -1010,7 +1025,7 @@ template <class _Tp> struct __has_void_pointer { private: - struct __two {char _; char __;}; + struct __two {char __lx; char __lxx;}; template <class _Up> static __two __test(...); template <class _Up> static char __test(typename _Up::void_pointer* = 0); public: @@ -1037,7 +1052,7 @@ template <class _Tp> struct __has_const_void_pointer { private: - struct __two {char _; char __;}; + struct __two {char __lx; char __lxx;}; template <class _Up> static __two __test(...); template <class _Up> static char __test(typename _Up::const_void_pointer* = 0); public: @@ -1060,10 +1075,10 @@ struct __const_void_pointer<_Ptr, _Alloc, false> #endif }; -template <class _T> +template <class _Tp> inline _LIBCPP_INLINE_VISIBILITY -_T* -__to_raw_pointer(_T* __p) _NOEXCEPT +_Tp* +__to_raw_pointer(_Tp* __p) _NOEXCEPT { return __p; } @@ -1080,7 +1095,7 @@ template <class _Tp> struct __has_size_type { private: - struct __two {char _; char __;}; + struct __two {char __lx; char __lxx;}; template <class _Up> static __two __test(...); template <class _Up> static char __test(typename _Up::size_type* = 0); public: @@ -1103,7 +1118,7 @@ template <class _Tp> struct __has_propagate_on_container_copy_assignment { private: - struct __two {char _; char __;}; + struct __two {char __lx; char __lxx;}; template <class _Up> static __two __test(...); template <class _Up> static char __test(typename _Up::propagate_on_container_copy_assignment* = 0); public: @@ -1126,7 +1141,7 @@ template <class _Tp> struct __has_propagate_on_container_move_assignment { private: - struct __two {char _; char __;}; + struct __two {char __lx; char __lxx;}; template <class _Up> static __two __test(...); template <class _Up> static char __test(typename _Up::propagate_on_container_move_assignment* = 0); public: @@ -1149,7 +1164,7 @@ template <class _Tp> struct __has_propagate_on_container_swap { private: - struct __two {char _; char __;}; + struct __two {char __lx; char __lxx;}; template <class _Up> static __two __test(...); template <class _Up> static char __test(typename _Up::propagate_on_container_swap* = 0); public: @@ -1172,7 +1187,7 @@ template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> struct __has_rebind_other { private: - struct __two {char _; char __;}; + struct __two {char __lx; char __lxx;}; template <class _Xp> static __two __test(...); template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0); public: @@ -1385,6 +1400,14 @@ struct __has_construct { }; +#else // _LIBCPP_HAS_NO_VARIADICS + +template <class _Alloc, class _Pointer, class _Args> +struct __has_construct + : false_type +{ +}; + #endif // _LIBCPP_HAS_NO_VARIADICS template <class _Alloc, class _Pointer> @@ -1514,6 +1537,63 @@ struct _LIBCPP_VISIBLE allocator_traits __has_select_on_container_copy_construction<const allocator_type>(), __a);} + template <class _Ptr> + _LIBCPP_INLINE_VISIBILITY + static + void + __construct_forward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2) + { + for (; __begin1 != __end1; ++__begin1, ++__begin2) + construct(__a, _VSTD::__to_raw_pointer(__begin2), _VSTD::move_if_noexcept(*__begin1)); + } + + template <class _Tp> + _LIBCPP_INLINE_VISIBILITY + static + typename enable_if + < + (is_same<allocator_type, allocator<_Tp> >::value + || !__has_construct<allocator_type, _Tp*, _Tp>::value) && + is_trivially_move_constructible<_Tp>::value, + void + >::type + __construct_forward(allocator_type& __a, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2) + { + ptrdiff_t _Np = __end1 - __begin1; + _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp)); + __begin2 += _Np; + } + + template <class _Ptr> + _LIBCPP_INLINE_VISIBILITY + static + void + __construct_backward(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2) + { + while (__end1 != __begin1) + { + construct(__a, _VSTD::__to_raw_pointer(__end2-1), _VSTD::move_if_noexcept(*--__end1)); + --__end2; + } + } + + template <class _Tp> + _LIBCPP_INLINE_VISIBILITY + static + typename enable_if + < + (is_same<allocator_type, allocator<_Tp> >::value + || !__has_construct<allocator_type, _Tp*, _Tp>::value) && + is_trivially_move_constructible<_Tp>::value, + void + >::type + __construct_backward(allocator_type& __a, _Tp* __begin1, _Tp* __end1, _Tp*& __end2) + { + ptrdiff_t _Np = __end1 - __begin1; + __end2 -= _Np; + _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp)); + } + private: _LIBCPP_INLINE_VISIBILITY @@ -1522,7 +1602,7 @@ private: {return __a.allocate(__n, __hint);} _LIBCPP_INLINE_VISIBILITY static pointer allocate(allocator_type& __a, size_type __n, - const_void_pointer __hint, false_type) + const_void_pointer, false_type) {return __a.allocate(__n);} #ifndef _LIBCPP_HAS_NO_VARIADICS @@ -1566,58 +1646,6 @@ private: {return __a;} }; -// uses_allocator - -template <class _Tp> -struct __has_allocator_type -{ -private: - struct __two {char _; char __;}; - template <class _Up> static __two __test(...); - template <class _Up> static char __test(typename _Up::allocator_type* = 0); -public: - static const bool value = sizeof(__test<_Tp>(0)) == 1; -}; - -template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value> -struct __uses_allocator - : public integral_constant<bool, - is_convertible<_Alloc, typename _Tp::allocator_type>::value> -{ -}; - -template <class _Tp, class _Alloc> -struct __uses_allocator<_Tp, _Alloc, false> - : public false_type -{ -}; - -template <class _Tp, class _Alloc> -struct _LIBCPP_VISIBLE uses_allocator - : public __uses_allocator<_Tp, _Alloc> -{ -}; - -#ifndef _LIBCPP_HAS_NO_VARIADICS - -// uses-allocator construction - -template <class _Tp, class _Alloc, class ..._Args> -struct __uses_alloc_ctor_imp -{ - static const bool __ua = uses_allocator<_Tp, _Alloc>::value; - static const bool __ic = - is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value; - static const int value = __ua ? 2 - __ic : 0; -}; - -template <class _Tp, class _Alloc, class ..._Args> -struct __uses_alloc_ctor - : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value> - {}; - -#endif // _LIBCPP_HAS_NO_VARIADICS - // allocator template <class _Tp> @@ -1664,38 +1692,110 @@ public: ::new((void*)__p) _Tp(); } # if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) + template <class _A0> _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - !is_convertible<_A0, __rv<_A0> >::value, - void - >::type + void construct(pointer __p, _A0& __a0) { ::new((void*)__p) _Tp(__a0); } template <class _A0> _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - !is_convertible<_A0, __rv<_A0> >::value, - void - >::type + void construct(pointer __p, const _A0& __a0) { ::new((void*)__p) _Tp(__a0); } +# endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) + template <class _A0, class _A1> + _LIBCPP_INLINE_VISIBILITY + void + construct(pointer __p, _A0& __a0, _A1& __a1) + { + ::new((void*)__p) _Tp(__a0, __a1); + } + template <class _A0, class _A1> + _LIBCPP_INLINE_VISIBILITY + void + construct(pointer __p, const _A0& __a0, _A1& __a1) + { + ::new((void*)__p) _Tp(__a0, __a1); + } + template <class _A0, class _A1> + _LIBCPP_INLINE_VISIBILITY + void + construct(pointer __p, _A0& __a0, const _A1& __a1) + { + ::new((void*)__p) _Tp(__a0, __a1); + } + template <class _A0, class _A1> + _LIBCPP_INLINE_VISIBILITY + void + construct(pointer __p, const _A0& __a0, const _A1& __a1) + { + ::new((void*)__p) _Tp(__a0, __a1); + } +#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) + _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();} +}; + +template <class _Tp> +class _LIBCPP_VISIBLE allocator<const _Tp> +{ +public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp* const_pointer; + typedef const _Tp& reference; + typedef const _Tp& const_reference; + typedef _Tp value_type; + + typedef true_type propagate_on_container_move_assignment; + + template <class _Up> struct rebind {typedef allocator<_Up> other;}; + + _LIBCPP_INLINE_VISIBILITY allocator() _NOEXCEPT {} + template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) _NOEXCEPT {} + _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT + {return _VSTD::addressof(__x);} + _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0) + {return static_cast<pointer>(::operator new(__n * sizeof(_Tp)));} + _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT + {::operator delete((void*)__p);} + _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT + {return size_type(~0) / sizeof(_Tp);} +#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) + template <class _Up, class... _Args> + _LIBCPP_INLINE_VISIBILITY + void + construct(_Up* __p, _Args&&... __args) + { + ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...); + } +#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) + _LIBCPP_INLINE_VISIBILITY + void + construct(pointer __p) + { + ::new((void*)__p) _Tp(); + } +# if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) + template <class _A0> _LIBCPP_INLINE_VISIBILITY - typename enable_if - < - is_convertible<_A0, __rv<_A0> >::value, - void - >::type - construct(pointer __p, _A0 __a0) + void + construct(pointer __p, _A0& __a0) { - ::new((void*)__p) _Tp(_VSTD::move(__a0)); + ::new((void*)__p) _Tp(__a0); + } + template <class _A0> + _LIBCPP_INLINE_VISIBILITY + void + construct(pointer __p, const _A0& __a0) + { + ::new((void*)__p) _Tp(__a0); } # endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) template <class _A0, class _A1> @@ -1844,8 +1944,16 @@ public: template <class _T1, class _T2, bool = is_same<typename remove_cv<_T1>::type, typename remove_cv<_T2>::type>::value, - bool = is_empty<_T1>::value, - bool = is_empty<_T2>::value> + bool = is_empty<_T1>::value +#if __has_feature(is_final) + && !__is_final(_T1) +#endif + , + bool = is_empty<_T2>::value +#if __has_feature(is_final) + && !__is_final(_T2) +#endif + > struct __libcpp_compressed_pair_switch; template <class _T1, class _T2, bool IsSame> @@ -1883,9 +1991,9 @@ public: typedef const typename remove_reference<_T2>::type& _T2_const_reference; _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} - _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1, int = 0) + _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1) : __first_(_VSTD::forward<_T1_param>(__t1)) {} - _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2, int* = 0) + _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2) : __second_(_VSTD::forward<_T2_param>(__t2)) {} _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) : __first_(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {} @@ -1928,6 +2036,21 @@ public: return *this; } +#ifndef _LIBCPP_HAS_NO_VARIADICS + + template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> + _LIBCPP_INLINE_VISIBILITY + __libcpp_compressed_pair_imp(piecewise_construct_t __pc, + tuple<_Args1...> __first_args, + tuple<_Args2...> __second_args, + __tuple_indices<_I1...>, + __tuple_indices<_I2...>) + : __first_(_VSTD::forward<_Args1>(get<_I1>(__first_args))...), + __second_(_VSTD::forward<_Args2>(get<_I2>(__second_args))...) + {} + +#endif // _LIBCPP_HAS_NO_VARIADICS + #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS @@ -1965,9 +2088,9 @@ public: typedef const typename remove_reference<_T2>::type& _T2_const_reference; _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {} - _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1, int = 0) + _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1) : _T1(_VSTD::forward<_T1_param>(__t1)) {} - _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2, int* = 0) + _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2) : __second_(_VSTD::forward<_T2_param>(__t2)) {} _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2) : _T1(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {} @@ -2008,6 +2131,21 @@ public: return *this; } +#ifndef _LIBCPP_HAS_NO_VARIADICS + + template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> + _LIBCPP_INLINE_VISIBILITY + __libcpp_compressed_pair_imp(piecewise_construct_t __pc, + tuple<_Args1...> __first_args, + tuple<_Args2...> __second_args, + __tuple_indices<_I1...>, + __tuple_indices<_I2...>) + : _T1(_VSTD::forward<_Args1>(get<_I1>(__first_args))...), + __second_(_VSTD::forward<_Args2>(get<_I2>(__second_args))...) + {} + +#endif // _LIBCPP_HAS_NO_VARIADICS + #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS @@ -2089,6 +2227,22 @@ public: return *this; } +#ifndef _LIBCPP_HAS_NO_VARIADICS + + template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> + _LIBCPP_INLINE_VISIBILITY + __libcpp_compressed_pair_imp(piecewise_construct_t __pc, + tuple<_Args1...> __first_args, + tuple<_Args2...> __second_args, + __tuple_indices<_I1...>, + __tuple_indices<_I2...>) + : _T2(_VSTD::forward<_Args2>(get<_I2>(__second_args))...), + __first_(_VSTD::forward<_Args1>(get<_I1>(__first_args))...) + + {} + +#endif // _LIBCPP_HAS_NO_VARIADICS + #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS @@ -2167,6 +2321,21 @@ public: return *this; } +#ifndef _LIBCPP_HAS_NO_VARIADICS + + template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2> + _LIBCPP_INLINE_VISIBILITY + __libcpp_compressed_pair_imp(piecewise_construct_t __pc, + tuple<_Args1...> __first_args, + tuple<_Args2...> __second_args, + __tuple_indices<_I1...>, + __tuple_indices<_I2...>) + : _T1(_VSTD::forward<_Args1>(get<_I1>(__first_args))...), + _T2(_VSTD::forward<_Args2>(get<_I2>(__second_args))...) + {} + +#endif // _LIBCPP_HAS_NO_VARIADICS + #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS @@ -2177,7 +2346,7 @@ public: _LIBCPP_INLINE_VISIBILITY _T2_reference second() _NOEXCEPT {return *this;} _LIBCPP_INLINE_VISIBILITY _T2_const_reference second() const _NOEXCEPT {return *this;} - _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp& __x) + _LIBCPP_INLINE_VISIBILITY void swap(__libcpp_compressed_pair_imp&) _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T1>::value) { @@ -2200,9 +2369,9 @@ public: typedef typename base::_T2_const_reference _T2_const_reference; _LIBCPP_INLINE_VISIBILITY __compressed_pair() {} - _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T1_param __t1, int = 0) + _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T1_param __t1) : base(_VSTD::forward<_T1_param>(__t1)) {} - _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T2_param __t2, int* = 0) + _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T2_param __t2) : base(_VSTD::forward<_T2_param>(__t2)) {} _LIBCPP_INLINE_VISIBILITY __compressed_pair(_T1_param __t1, _T2_param __t2) : base(_VSTD::forward<_T1_param>(__t1), _VSTD::forward<_T2_param>(__t2)) {} @@ -2239,6 +2408,20 @@ public: base::operator=(_VSTD::move(__p)); return *this; } + +#ifndef _LIBCPP_HAS_NO_VARIADICS + + template <class... _Args1, class... _Args2> + _LIBCPP_INLINE_VISIBILITY + __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, + tuple<_Args2...> __second_args) + : base(__pc, _VSTD::move(__first_args), _VSTD::move(__second_args), + typename __make_tuple_indices<sizeof...(_Args1)>::type(), + typename __make_tuple_indices<sizeof...(_Args2) >::type()) + {} + +#endif // _LIBCPP_HAS_NO_VARIADICS + #endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES #endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS @@ -2263,10 +2446,39 @@ swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y) __is_nothrow_swappable<_T1>::value) {__x.swap(__y);} +// __same_or_less_cv_qualified + +template <class _Ptr1, class _Ptr2, + bool = is_same<typename remove_cv<typename pointer_traits<_Ptr1>::element_type>::type, + typename remove_cv<typename pointer_traits<_Ptr2>::element_type>::type + >::value + > +struct __same_or_less_cv_qualified_imp + : is_convertible<_Ptr1, _Ptr2> {}; + +template <class _Ptr1, class _Ptr2> +struct __same_or_less_cv_qualified_imp<_Ptr1, _Ptr2, false> + : false_type {}; + +template <class _Ptr1, class _Ptr2, bool = is_scalar<_Ptr1>::value && + !is_pointer<_Ptr1>::value> +struct __same_or_less_cv_qualified + : __same_or_less_cv_qualified_imp<_Ptr1, _Ptr2> {}; + +template <class _Ptr1, class _Ptr2> +struct __same_or_less_cv_qualified<_Ptr1, _Ptr2, true> + : false_type {}; + +// default_delete + template <class _Tp> struct _LIBCPP_VISIBLE default_delete { - _LIBCPP_INLINE_VISIBILITY default_delete() _NOEXCEPT {} +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT = default; +#else + _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT {} +#endif template <class _Up> _LIBCPP_INLINE_VISIBILITY default_delete(const default_delete<_Up>&, typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = 0) _NOEXCEPT {} @@ -2280,13 +2492,23 @@ struct _LIBCPP_VISIBLE default_delete template <class _Tp> struct _LIBCPP_VISIBLE default_delete<_Tp[]> { - _LIBCPP_INLINE_VISIBILITY void operator() (_Tp* __ptr) const _NOEXCEPT +public: +#ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS + _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT = default; +#else + _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR default_delete() _NOEXCEPT {} +#endif + template <class _Up> + _LIBCPP_INLINE_VISIBILITY default_delete(const default_delete<_Up[]>&, + typename enable_if<__same_or_less_cv_qualified<_Up*, _Tp*>::value>::type* = 0) _NOEXCEPT {} + template <class _Up> + _LIBCPP_INLINE_VISIBILITY + void operator() (_Up* __ptr, + typename enable_if<__same_or_less_cv_qualified<_Up*, _Tp*>::value>::type* = 0) const _NOEXCEPT { static_assert(sizeof(_Tp) > 0, "default_delete can not delete incomplete type"); delete [] __ptr; } -private: - template <class _Up> void operator() (_Up*) const; }; template <class _Tp, class _Dp = default_delete<_Tp> > @@ -2299,14 +2521,7 @@ public: private: __compressed_pair<pointer, deleter_type> __ptr_; -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - unique_ptr(const unique_ptr&); - unique_ptr& operator=(const unique_ptr&); - template <class _Up, class _Ep> - unique_ptr(const unique_ptr<_Up, _Ep>&); - template <class _Up, class _Ep> - unique_ptr& operator=(const unique_ptr<_Up, _Ep>&); -#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES +#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES unique_ptr(unique_ptr&); template <class _Up, class _Ep> unique_ptr(unique_ptr<_Up, _Ep>&); @@ -2320,13 +2535,13 @@ private: typedef typename remove_reference<deleter_type>::type& _Dp_reference; typedef const typename remove_reference<deleter_type>::type& _Dp_const_reference; public: - _LIBCPP_INLINE_VISIBILITY unique_ptr() _NOEXCEPT + _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer()) { static_assert(!is_pointer<deleter_type>::value, "unique_ptr constructed with null function pointer deleter"); } - _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t) _NOEXCEPT + _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer()) { static_assert(!is_pointer<deleter_type>::value, @@ -2393,7 +2608,9 @@ public: _LIBCPP_INLINE_VISIBILITY typename enable_if < - !is_array<_Up>::value, + !is_array<_Up>::value && + is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value && + is_assignable<deleter_type&, _Ep&&>::value, unique_ptr& >::type operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT @@ -2450,9 +2667,9 @@ public: {return __ptr_.second();} _LIBCPP_INLINE_VISIBILITY _Dp_const_reference get_deleter() const _NOEXCEPT {return __ptr_.second();} - _LIBCPP_INLINE_VISIBILITY operator int __nat::*() const - _NOEXCEPT - {return __ptr_.first() ? &__nat::__for_bool_ : 0;} + _LIBCPP_INLINE_VISIBILITY + _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT + {return __ptr_.first() != nullptr;} _LIBCPP_INLINE_VISIBILITY pointer release() _NOEXCEPT { @@ -2483,10 +2700,7 @@ public: private: __compressed_pair<pointer, deleter_type> __ptr_; -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - unique_ptr(const unique_ptr&); - unique_ptr& operator=(const unique_ptr&); -#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES +#ifdef _LIBCPP_HAS_NO_RVALUE_REFERENCES unique_ptr(unique_ptr&); template <class _Up> unique_ptr(unique_ptr<_Up>&); @@ -2500,33 +2714,33 @@ private: typedef typename remove_reference<deleter_type>::type& _Dp_reference; typedef const typename remove_reference<deleter_type>::type& _Dp_const_reference; public: - _LIBCPP_INLINE_VISIBILITY unique_ptr() _NOEXCEPT + _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(pointer()) { static_assert(!is_pointer<deleter_type>::value, "unique_ptr constructed with null function pointer deleter"); } - _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t) _NOEXCEPT + _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(pointer()) { static_assert(!is_pointer<deleter_type>::value, "unique_ptr constructed with null function pointer deleter"); } #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - template <class _P, - class = typename enable_if<is_same<_P, pointer>::value>::type + template <class _Pp, + class = typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value>::type > - _LIBCPP_INLINE_VISIBILITY explicit unique_ptr(_P __p) _NOEXCEPT + _LIBCPP_INLINE_VISIBILITY explicit unique_ptr(_Pp __p) _NOEXCEPT : __ptr_(__p) { static_assert(!is_pointer<deleter_type>::value, "unique_ptr constructed with null function pointer deleter"); } - template <class _P, - class = typename enable_if<is_same<_P, pointer>::value>::type + template <class _Pp, + class = typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value>::type > - _LIBCPP_INLINE_VISIBILITY unique_ptr(_P __p, typename conditional< + _LIBCPP_INLINE_VISIBILITY unique_ptr(_Pp __p, typename conditional< is_reference<deleter_type>::value, deleter_type, typename add_lvalue_reference<const deleter_type>::type>::type __d) @@ -2540,11 +2754,10 @@ public: _NOEXCEPT : __ptr_(pointer(), __d) {} - template <class _P, - class = typename enable_if<is_same<_P, pointer>::value || - is_same<_P, nullptr_t>::value>::type + template <class _Pp, + class = typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value>::type > - _LIBCPP_INLINE_VISIBILITY unique_ptr(_P __p, typename remove_reference<deleter_type>::type&& __d) + _LIBCPP_INLINE_VISIBILITY unique_ptr(_Pp __p, typename remove_reference<deleter_type>::type&& __d) _NOEXCEPT : __ptr_(__p, _VSTD::move(__d)) { @@ -2567,6 +2780,40 @@ public: __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter()); return *this; } + + template <class _Up, class _Ep> + _LIBCPP_INLINE_VISIBILITY + unique_ptr(unique_ptr<_Up, _Ep>&& __u, + typename enable_if + < + is_array<_Up>::value && + __same_or_less_cv_qualified<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value + && is_convertible<_Ep, deleter_type>::value && + ( + !is_reference<deleter_type>::value || + is_same<deleter_type, _Ep>::value + ), + __nat + >::type = __nat() + ) _NOEXCEPT + : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {} + + + template <class _Up, class _Ep> + _LIBCPP_INLINE_VISIBILITY + typename enable_if + < + is_array<_Up>::value && + __same_or_less_cv_qualified<typename unique_ptr<_Up, _Ep>::pointer, pointer>::value && + is_assignable<deleter_type&, _Ep&&>::value, + unique_ptr& + >::type + operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT + { + reset(__u.release()); + __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter()); + return *this; + } #else // _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY explicit unique_ptr(pointer __p) @@ -2613,8 +2860,9 @@ public: {return __ptr_.second();} _LIBCPP_INLINE_VISIBILITY _Dp_const_reference get_deleter() const _NOEXCEPT {return __ptr_.second();} - _LIBCPP_INLINE_VISIBILITY operator int __nat::*() const _NOEXCEPT - {return __ptr_.first() ? &__nat::__for_bool_ : 0;} + _LIBCPP_INLINE_VISIBILITY + _LIBCPP_EXPLICIT operator bool() const _NOEXCEPT + {return __ptr_.first() != nullptr;} _LIBCPP_INLINE_VISIBILITY pointer release() _NOEXCEPT { @@ -2624,10 +2872,10 @@ public: } #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - template <class _P, - class = typename enable_if<is_same<_P, pointer>::value>::type + template <class _Pp, + class = typename enable_if<__same_or_less_cv_qualified<_Pp, pointer>::value>::type > - _LIBCPP_INLINE_VISIBILITY void reset(_P __p) _NOEXCEPT + _LIBCPP_INLINE_VISIBILITY void reset(_Pp __p) _NOEXCEPT { pointer __tmp = __ptr_.first(); __ptr_.first() = __p; @@ -2696,7 +2944,13 @@ operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {re 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();} +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 _V; + return less<_V>()(__x.get(), __y.get()); +} template <class _T1, class _D1, class _T2, class _D2> inline _LIBCPP_INLINE_VISIBILITY @@ -2713,8 +2967,431 @@ 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); |