diff options
Diffstat (limited to 'data/iphoneos-sdk/v1/scoped_allocator')
| -rwxr-xr-x | data/iphoneos-sdk/v1/scoped_allocator | 683 |
1 files changed, 683 insertions, 0 deletions
diff --git a/data/iphoneos-sdk/v1/scoped_allocator b/data/iphoneos-sdk/v1/scoped_allocator new file mode 100755 index 000000000..4760d946d --- /dev/null +++ b/data/iphoneos-sdk/v1/scoped_allocator @@ -0,0 +1,683 @@ +// -*- C++ -*- +//===-------------------------- scoped_allocator --------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SCOPED_ALLOCATOR +#define _LIBCPP_SCOPED_ALLOCATOR + +/* + scoped_allocator synopsis + +namespace std +{ + +template <class OuterAlloc, class... InnerAllocs> +class scoped_allocator_adaptor : public OuterAlloc +{ + typedef allocator_traits<OuterAlloc> OuterTraits; // exposition only + scoped_allocator_adaptor<InnerAllocs...> inner; // exposition only +public: + + typedef OuterAlloc outer_allocator_type; + typedef see below inner_allocator_type; + + typedef typename OuterTraits::value_type value_type; + typedef typename OuterTraits::size_type size_type; + typedef typename OuterTraits::difference_type difference_type; + typedef typename OuterTraits::pointer pointer; + typedef typename OuterTraits::const_pointer const_pointer; + typedef typename OuterTraits::void_pointer void_pointer; + typedef typename OuterTraits::const_void_pointer const_void_pointer; + + typedef see below propagate_on_container_copy_assignment; + typedef see below propagate_on_container_move_assignment; + typedef see below propagate_on_container_swap; + typedef see below is_always_equal; + + template <class Tp> + struct rebind + { + typedef scoped_allocator_adaptor< + OuterTraits::template rebind_alloc<Tp>, InnerAllocs...> other; + }; + + scoped_allocator_adaptor(); + template <class OuterA2> + scoped_allocator_adaptor(OuterA2&& outerAlloc, + const InnerAllocs&... innerAllocs) noexcept; + scoped_allocator_adaptor(const scoped_allocator_adaptor& other) noexcept; + scoped_allocator_adaptor(scoped_allocator_adaptor&& other) noexcept; + template <class OuterA2> + scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other) noexcept; + template <class OuterA2> + scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other) noexcept; + + scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default; + scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default; + ~scoped_allocator_adaptor(); + + inner_allocator_type& inner_allocator() noexcept; + const inner_allocator_type& inner_allocator() const noexcept; + + outer_allocator_type& outer_allocator() noexcept; + const outer_allocator_type& outer_allocator() const noexcept; + + pointer allocate(size_type n); // [[nodiscard]] in C++20 + pointer allocate(size_type n, const_void_pointer hint); // [[nodiscard]] in C++20 + void deallocate(pointer p, size_type n) noexcept; + + size_type max_size() const; + template <class T, class... Args> void construct(T* p, Args&& args); + template <class T1, class T2, class... Args1, class... Args2> + void construct(pair<T1, T2>* p, piecewise_construct t, tuple<Args1...> x, + tuple<Args2...> y); + template <class T1, class T2> + void construct(pair<T1, T2>* p); + template <class T1, class T2, class U, class V> + void construct(pair<T1, T2>* p, U&& x, V&& y); + template <class T1, class T2, class U, class V> + void construct(pair<T1, T2>* p, const pair<U, V>& x); + template <class T1, class T2, class U, class V> + void construct(pair<T1, T2>* p, pair<U, V>&& x); + template <class T> void destroy(T* p); + + template <class T> void destroy(T* p) noexcept; + + scoped_allocator_adaptor select_on_container_copy_construction() const noexcept; +}; + +template <class OuterA1, class OuterA2, class... InnerAllocs> + bool + operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a, + const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept; + +template <class OuterA1, class OuterA2, class... InnerAllocs> + bool + operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a, + const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept; + +} // std + +*/ + +#include <__config> +#include <memory> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if !defined(_LIBCPP_CXX03_LANG) + +// scoped_allocator_adaptor + +template <class ..._Allocs> +class scoped_allocator_adaptor; + +template <class ..._Allocs> struct __get_poc_copy_assignment; + +template <class _A0> +struct __get_poc_copy_assignment<_A0> +{ + static const bool value = allocator_traits<_A0>:: + propagate_on_container_copy_assignment::value; +}; + +template <class _A0, class ..._Allocs> +struct __get_poc_copy_assignment<_A0, _Allocs...> +{ + static const bool value = + allocator_traits<_A0>::propagate_on_container_copy_assignment::value || + __get_poc_copy_assignment<_Allocs...>::value; +}; + +template <class ..._Allocs> struct __get_poc_move_assignment; + +template <class _A0> +struct __get_poc_move_assignment<_A0> +{ + static const bool value = allocator_traits<_A0>:: + propagate_on_container_move_assignment::value; +}; + +template <class _A0, class ..._Allocs> +struct __get_poc_move_assignment<_A0, _Allocs...> +{ + static const bool value = + allocator_traits<_A0>::propagate_on_container_move_assignment::value || + __get_poc_move_assignment<_Allocs...>::value; +}; + +template <class ..._Allocs> struct __get_poc_swap; + +template <class _A0> +struct __get_poc_swap<_A0> +{ + static const bool value = allocator_traits<_A0>:: + propagate_on_container_swap::value; +}; + +template <class _A0, class ..._Allocs> +struct __get_poc_swap<_A0, _Allocs...> +{ + static const bool value = + allocator_traits<_A0>::propagate_on_container_swap::value || + __get_poc_swap<_Allocs...>::value; +}; + +template <class ..._Allocs> struct __get_is_always_equal; + +template <class _A0> +struct __get_is_always_equal<_A0> +{ + static const bool value = allocator_traits<_A0>::is_always_equal::value; +}; + +template <class _A0, class ..._Allocs> +struct __get_is_always_equal<_A0, _Allocs...> +{ + static const bool value = + allocator_traits<_A0>::is_always_equal::value && + __get_is_always_equal<_Allocs...>::value; +}; + +template <class ..._Allocs> +class __scoped_allocator_storage; + +template <class _OuterAlloc, class... _InnerAllocs> +class __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> + : public _OuterAlloc +{ + typedef _OuterAlloc outer_allocator_type; +protected: + typedef scoped_allocator_adaptor<_InnerAllocs...> inner_allocator_type; + +private: + inner_allocator_type __inner_; + +protected: + + _LIBCPP_INLINE_VISIBILITY + __scoped_allocator_storage() _NOEXCEPT {} + + template <class _OuterA2, + class = typename enable_if< + is_constructible<outer_allocator_type, _OuterA2>::value + >::type> + _LIBCPP_INLINE_VISIBILITY + __scoped_allocator_storage(_OuterA2&& __outerAlloc, + const _InnerAllocs& ...__innerAllocs) _NOEXCEPT + : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)), + __inner_(__innerAllocs...) {} + + template <class _OuterA2, + class = typename enable_if< + is_constructible<outer_allocator_type, const _OuterA2&>::value + >::type> + _LIBCPP_INLINE_VISIBILITY + __scoped_allocator_storage( + const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT + : outer_allocator_type(__other.outer_allocator()), + __inner_(__other.inner_allocator()) {} + + template <class _OuterA2, + class = typename enable_if< + is_constructible<outer_allocator_type, _OuterA2>::value + >::type> + _LIBCPP_INLINE_VISIBILITY + __scoped_allocator_storage( + __scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT + : outer_allocator_type(_VSTD::move(__other.outer_allocator())), + __inner_(_VSTD::move(__other.inner_allocator())) {} + + template <class _OuterA2, + class = typename enable_if< + is_constructible<outer_allocator_type, _OuterA2>::value + >::type> + _LIBCPP_INLINE_VISIBILITY + __scoped_allocator_storage(_OuterA2&& __o, + const inner_allocator_type& __i) _NOEXCEPT + : outer_allocator_type(_VSTD::forward<_OuterA2>(__o)), + __inner_(__i) + { + } + + _LIBCPP_INLINE_VISIBILITY + inner_allocator_type& inner_allocator() _NOEXCEPT {return __inner_;} + _LIBCPP_INLINE_VISIBILITY + const inner_allocator_type& inner_allocator() const _NOEXCEPT {return __inner_;} + + _LIBCPP_INLINE_VISIBILITY + outer_allocator_type& outer_allocator() _NOEXCEPT + {return static_cast<outer_allocator_type&>(*this);} + _LIBCPP_INLINE_VISIBILITY + const outer_allocator_type& outer_allocator() const _NOEXCEPT + {return static_cast<const outer_allocator_type&>(*this);} + + scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...> + _LIBCPP_INLINE_VISIBILITY + select_on_container_copy_construction() const _NOEXCEPT + { + return scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...> + ( + allocator_traits<outer_allocator_type>:: + select_on_container_copy_construction(outer_allocator()), + allocator_traits<inner_allocator_type>:: + select_on_container_copy_construction(inner_allocator()) + ); + } + + template <class...> friend class __scoped_allocator_storage; +}; + +template <class _OuterAlloc> +class __scoped_allocator_storage<_OuterAlloc> + : public _OuterAlloc +{ + typedef _OuterAlloc outer_allocator_type; +protected: + typedef scoped_allocator_adaptor<_OuterAlloc> inner_allocator_type; + + _LIBCPP_INLINE_VISIBILITY + __scoped_allocator_storage() _NOEXCEPT {} + + template <class _OuterA2, + class = typename enable_if< + is_constructible<outer_allocator_type, _OuterA2>::value + >::type> + _LIBCPP_INLINE_VISIBILITY + __scoped_allocator_storage(_OuterA2&& __outerAlloc) _NOEXCEPT + : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)) {} + + template <class _OuterA2, + class = typename enable_if< + is_constructible<outer_allocator_type, const _OuterA2&>::value + >::type> + _LIBCPP_INLINE_VISIBILITY + __scoped_allocator_storage( + const __scoped_allocator_storage<_OuterA2>& __other) _NOEXCEPT + : outer_allocator_type(__other.outer_allocator()) {} + + template <class _OuterA2, + class = typename enable_if< + is_constructible<outer_allocator_type, _OuterA2>::value + >::type> + _LIBCPP_INLINE_VISIBILITY + __scoped_allocator_storage( + __scoped_allocator_storage<_OuterA2>&& __other) _NOEXCEPT + : outer_allocator_type(_VSTD::move(__other.outer_allocator())) {} + + _LIBCPP_INLINE_VISIBILITY + inner_allocator_type& inner_allocator() _NOEXCEPT + {return static_cast<inner_allocator_type&>(*this);} + _LIBCPP_INLINE_VISIBILITY + const inner_allocator_type& inner_allocator() const _NOEXCEPT + {return static_cast<const inner_allocator_type&>(*this);} + + _LIBCPP_INLINE_VISIBILITY + outer_allocator_type& outer_allocator() _NOEXCEPT + {return static_cast<outer_allocator_type&>(*this);} + _LIBCPP_INLINE_VISIBILITY + const outer_allocator_type& outer_allocator() const _NOEXCEPT + {return static_cast<const outer_allocator_type&>(*this);} + + _LIBCPP_INLINE_VISIBILITY + scoped_allocator_adaptor<outer_allocator_type> + select_on_container_copy_construction() const _NOEXCEPT + {return scoped_allocator_adaptor<outer_allocator_type>( + allocator_traits<outer_allocator_type>:: + select_on_container_copy_construction(outer_allocator()) + );} + + __scoped_allocator_storage(const outer_allocator_type& __o, + const inner_allocator_type& __i) _NOEXCEPT; + + template <class...> friend class __scoped_allocator_storage; +}; + +// __outermost + +template <class _Alloc> +decltype(declval<_Alloc>().outer_allocator(), true_type()) +__has_outer_allocator_test(_Alloc&& __a); + +template <class _Alloc> +false_type +__has_outer_allocator_test(const volatile _Alloc& __a); + +template <class _Alloc> +struct __has_outer_allocator + : public common_type + < + decltype(__has_outer_allocator_test(declval<_Alloc&>())) + >::type +{ +}; + +template <class _Alloc, bool = __has_outer_allocator<_Alloc>::value> +struct __outermost +{ + typedef _Alloc type; + _LIBCPP_INLINE_VISIBILITY + type& operator()(type& __a) const _NOEXCEPT {return __a;} +}; + +template <class _Alloc> +struct __outermost<_Alloc, true> +{ + typedef typename remove_reference + < + decltype(_VSTD::declval<_Alloc>().outer_allocator()) + >::type _OuterAlloc; + typedef typename __outermost<_OuterAlloc>::type type; + _LIBCPP_INLINE_VISIBILITY + type& operator()(_Alloc& __a) const _NOEXCEPT + {return __outermost<_OuterAlloc>()(__a.outer_allocator());} +}; + +template <class _OuterAlloc, class... _InnerAllocs> +class _LIBCPP_TEMPLATE_VIS scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...> + : public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> +{ + typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base; + typedef allocator_traits<_OuterAlloc> _OuterTraits; +public: + typedef _OuterAlloc outer_allocator_type; + typedef typename base::inner_allocator_type inner_allocator_type; + typedef typename _OuterTraits::size_type size_type; + typedef typename _OuterTraits::difference_type difference_type; + typedef typename _OuterTraits::pointer pointer; + typedef typename _OuterTraits::const_pointer const_pointer; + typedef typename _OuterTraits::void_pointer void_pointer; + typedef typename _OuterTraits::const_void_pointer const_void_pointer; + + typedef integral_constant + < + bool, + __get_poc_copy_assignment<outer_allocator_type, + _InnerAllocs...>::value + > propagate_on_container_copy_assignment; + typedef integral_constant + < + bool, + __get_poc_move_assignment<outer_allocator_type, + _InnerAllocs...>::value + > propagate_on_container_move_assignment; + typedef integral_constant + < + bool, + __get_poc_swap<outer_allocator_type, _InnerAllocs...>::value + > propagate_on_container_swap; + typedef integral_constant + < + bool, + __get_is_always_equal<outer_allocator_type, _InnerAllocs...>::value + > is_always_equal; + + template <class _Tp> + struct rebind + { + typedef scoped_allocator_adaptor + < + typename _OuterTraits::template rebind_alloc<_Tp>, _InnerAllocs... + > other; + }; + + _LIBCPP_INLINE_VISIBILITY + scoped_allocator_adaptor() _NOEXCEPT {} + template <class _OuterA2, + class = typename enable_if< + is_constructible<outer_allocator_type, _OuterA2>::value + >::type> + _LIBCPP_INLINE_VISIBILITY + scoped_allocator_adaptor(_OuterA2&& __outerAlloc, + const _InnerAllocs& ...__innerAllocs) _NOEXCEPT + : base(_VSTD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {} + // scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default; + template <class _OuterA2, + class = typename enable_if< + is_constructible<outer_allocator_type, const _OuterA2&>::value + >::type> + _LIBCPP_INLINE_VISIBILITY + scoped_allocator_adaptor( + const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT + : base(__other) {} + template <class _OuterA2, + class = typename enable_if< + is_constructible<outer_allocator_type, _OuterA2>::value + >::type> + _LIBCPP_INLINE_VISIBILITY + scoped_allocator_adaptor( + scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT + : base(_VSTD::move(__other)) {} + + // scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default; + // scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default; + // ~scoped_allocator_adaptor() = default; + + _LIBCPP_INLINE_VISIBILITY + inner_allocator_type& inner_allocator() _NOEXCEPT + {return base::inner_allocator();} + _LIBCPP_INLINE_VISIBILITY + const inner_allocator_type& inner_allocator() const _NOEXCEPT + {return base::inner_allocator();} + + _LIBCPP_INLINE_VISIBILITY + outer_allocator_type& outer_allocator() _NOEXCEPT + {return base::outer_allocator();} + _LIBCPP_INLINE_VISIBILITY + const outer_allocator_type& outer_allocator() const _NOEXCEPT + {return base::outer_allocator();} + + _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY + pointer allocate(size_type __n) + {return allocator_traits<outer_allocator_type>:: + allocate(outer_allocator(), __n);} + _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY + pointer allocate(size_type __n, const_void_pointer __hint) + {return allocator_traits<outer_allocator_type>:: + allocate(outer_allocator(), __n, __hint);} + + _LIBCPP_INLINE_VISIBILITY + void deallocate(pointer __p, size_type __n) _NOEXCEPT + {allocator_traits<outer_allocator_type>:: + deallocate(outer_allocator(), __p, __n);} + + _LIBCPP_INLINE_VISIBILITY + size_type max_size() const + {return allocator_traits<outer_allocator_type>::max_size(outer_allocator());} + + template <class _Tp, class... _Args> + _LIBCPP_INLINE_VISIBILITY + void construct(_Tp* __p, _Args&& ...__args) + {__construct(__uses_alloc_ctor<_Tp, inner_allocator_type&, _Args...>(), + __p, _VSTD::forward<_Args>(__args)...);} + + template <class _T1, class _T2, class... _Args1, class... _Args2> + void construct(pair<_T1, _T2>* __p, piecewise_construct_t, + tuple<_Args1...> __x, tuple<_Args2...> __y) + { + typedef __outermost<outer_allocator_type> _OM; + allocator_traits<typename _OM::type>::construct( + _OM()(outer_allocator()), __p, piecewise_construct + , __transform_tuple( + typename __uses_alloc_ctor< + _T1, inner_allocator_type&, _Args1... + >::type() + , _VSTD::move(__x) + , typename __make_tuple_indices<sizeof...(_Args1)>::type{} + ) + , __transform_tuple( + typename __uses_alloc_ctor< + _T2, inner_allocator_type&, _Args2... + >::type() + , _VSTD::move(__y) + , typename __make_tuple_indices<sizeof...(_Args2)>::type{} + ) + ); + } + + template <class _T1, class _T2> + void construct(pair<_T1, _T2>* __p) + { construct(__p, piecewise_construct, tuple<>{}, tuple<>{}); } + + template <class _T1, class _T2, class _Up, class _Vp> + void construct(pair<_T1, _T2>* __p, _Up&& __x, _Vp&& __y) { + construct(__p, piecewise_construct, + _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__x)), + _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__y))); + } + + template <class _T1, class _T2, class _Up, class _Vp> + void construct(pair<_T1, _T2>* __p, const pair<_Up, _Vp>& __x) { + construct(__p, piecewise_construct, + _VSTD::forward_as_tuple(__x.first), + _VSTD::forward_as_tuple(__x.second)); + } + + template <class _T1, class _T2, class _Up, class _Vp> + void construct(pair<_T1, _T2>* __p, pair<_Up, _Vp>&& __x) { + construct(__p, piecewise_construct, + _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__x.first)), + _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__x.second))); + } + + template <class _Tp> + _LIBCPP_INLINE_VISIBILITY + void destroy(_Tp* __p) + { + typedef __outermost<outer_allocator_type> _OM; + allocator_traits<typename _OM::type>:: + destroy(_OM()(outer_allocator()), __p); + } + + _LIBCPP_INLINE_VISIBILITY + scoped_allocator_adaptor select_on_container_copy_construction() const _NOEXCEPT + {return base::select_on_container_copy_construction();} + +private: + + + template <class _OuterA2, + class = typename enable_if< + is_constructible<outer_allocator_type, _OuterA2>::value + >::type> + _LIBCPP_INLINE_VISIBILITY + scoped_allocator_adaptor(_OuterA2&& __o, + const inner_allocator_type& __i) _NOEXCEPT + : base(_VSTD::forward<_OuterA2>(__o), __i) {} + + template <class _Tp, class... _Args> + _LIBCPP_INLINE_VISIBILITY + void __construct(integral_constant<int, 0>, _Tp* __p, _Args&& ...__args) + { + typedef __outermost<outer_allocator_type> _OM; + allocator_traits<typename _OM::type>::construct + ( + _OM()(outer_allocator()), + __p, + _VSTD::forward<_Args>(__args)... + ); + } + + template <class _Tp, class... _Args> + _LIBCPP_INLINE_VISIBILITY + void __construct(integral_constant<int, 1>, _Tp* __p, _Args&& ...__args) + { + typedef __outermost<outer_allocator_type> _OM; + allocator_traits<typename _OM::type>::construct + ( + _OM()(outer_allocator()), + __p, allocator_arg, inner_allocator(), + _VSTD::forward<_Args>(__args)... + ); + } + + template <class _Tp, class... _Args> + _LIBCPP_INLINE_VISIBILITY + void __construct(integral_constant<int, 2>, _Tp* __p, _Args&& ...__args) + { + typedef __outermost<outer_allocator_type> _OM; + allocator_traits<typename _OM::type>::construct + ( + _OM()(outer_allocator()), + __p, + _VSTD::forward<_Args>(__args)..., + inner_allocator() + ); + } + + template <class ..._Args, size_t ..._Idx> + _LIBCPP_INLINE_VISIBILITY + tuple<_Args&&...> + __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t, + __tuple_indices<_Idx...>) + { + return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...); + } + + template <class ..._Args, size_t ..._Idx> + _LIBCPP_INLINE_VISIBILITY + tuple<allocator_arg_t, inner_allocator_type&, _Args&&...> + __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t, + __tuple_indices<_Idx...>) + { + using _Tup = tuple<allocator_arg_t, inner_allocator_type&, _Args&&...>; + return _Tup(allocator_arg, inner_allocator(), + _VSTD::get<_Idx>(_VSTD::move(__t))...); + } + + template <class ..._Args, size_t ..._Idx> + _LIBCPP_INLINE_VISIBILITY + tuple<_Args&&..., inner_allocator_type&> + __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t, + __tuple_indices<_Idx...>) + { + using _Tup = tuple<_Args&&..., inner_allocator_type&>; + return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., inner_allocator()); + } + + template <class...> friend class __scoped_allocator_storage; +}; + +template <class _OuterA1, class _OuterA2> +inline _LIBCPP_INLINE_VISIBILITY +bool +operator==(const scoped_allocator_adaptor<_OuterA1>& __a, + const scoped_allocator_adaptor<_OuterA2>& __b) _NOEXCEPT +{ + return __a.outer_allocator() == __b.outer_allocator(); +} + +template <class _OuterA1, class _OuterA2, class _InnerA0, class... _InnerAllocs> +inline _LIBCPP_INLINE_VISIBILITY +bool +operator==(const scoped_allocator_adaptor<_OuterA1, _InnerA0, _InnerAllocs...>& __a, + const scoped_allocator_adaptor<_OuterA2, _InnerA0, _InnerAllocs...>& __b) _NOEXCEPT +{ + return __a.outer_allocator() == __b.outer_allocator() && + __a.inner_allocator() == __b.inner_allocator(); +} + +template <class _OuterA1, class _OuterA2, class... _InnerAllocs> +inline _LIBCPP_INLINE_VISIBILITY +bool +operator!=(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a, + const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b) _NOEXCEPT +{ + return !(__a == __b); +} + +#endif // !defined(_LIBCPP_CXX03_LANG) + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_SCOPED_ALLOCATOR |