| // -*- C++ -*- |
| //===----------------------------------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H |
| #define _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H |
| |
| #include <__config> |
| #include <__memory/base.h> |
| #include <__memory/pointer_traits.h> |
| #include <type_traits> |
| |
| #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
| #pragma GCC system_header |
| #endif |
| |
| _LIBCPP_PUSH_MACROS |
| #include <__undef_macros> |
| |
| _LIBCPP_BEGIN_NAMESPACE_STD |
| |
| template <class _Tp, class = void> |
| struct __has_pointer_type : false_type {}; |
| |
| template <class _Tp> |
| struct __has_pointer_type<_Tp, |
| typename __void_t<typename _Tp::pointer>::type> : true_type {}; |
| |
| namespace __pointer_type_imp |
| { |
| |
| template <class _Tp, class _Dp, bool = __has_pointer_type<_Dp>::value> |
| struct __pointer_type |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename _Dp::pointer type; |
| }; |
| |
| template <class _Tp, class _Dp> |
| struct __pointer_type<_Tp, _Dp, false> |
| { |
| typedef _LIBCPP_NODEBUG_TYPE _Tp* type; |
| }; |
| |
| } // __pointer_type_imp |
| |
| template <class _Tp, class _Dp> |
| struct __pointer_type |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename __pointer_type_imp::__pointer_type<_Tp, typename remove_reference<_Dp>::type>::type type; |
| }; |
| |
| template <class _Tp, class = void> |
| struct __has_const_pointer : false_type {}; |
| |
| template <class _Tp> |
| struct __has_const_pointer<_Tp, |
| typename __void_t<typename _Tp::const_pointer>::type> : true_type {}; |
| |
| template <class _Tp, class _Ptr, class _Alloc, bool = __has_const_pointer<_Alloc>::value> |
| struct __const_pointer |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::const_pointer type; |
| }; |
| |
| template <class _Tp, class _Ptr, class _Alloc> |
| struct __const_pointer<_Tp, _Ptr, _Alloc, false> |
| { |
| #ifndef _LIBCPP_CXX03_LANG |
| typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::template rebind<const _Tp> type; |
| #else |
| typedef typename pointer_traits<_Ptr>::template rebind<const _Tp>::other type; |
| #endif |
| }; |
| |
| template <class _Tp, class = void> |
| struct __has_void_pointer : false_type {}; |
| |
| template <class _Tp> |
| struct __has_void_pointer<_Tp, |
| typename __void_t<typename _Tp::void_pointer>::type> : true_type {}; |
| |
| template <class _Ptr, class _Alloc, bool = __has_void_pointer<_Alloc>::value> |
| struct __void_pointer |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::void_pointer type; |
| }; |
| |
| template <class _Ptr, class _Alloc> |
| struct __void_pointer<_Ptr, _Alloc, false> |
| { |
| #ifndef _LIBCPP_CXX03_LANG |
| typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::template rebind<void> type; |
| #else |
| typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::template rebind<void>::other type; |
| #endif |
| }; |
| |
| template <class _Tp, class = void> |
| struct __has_const_void_pointer : false_type {}; |
| |
| template <class _Tp> |
| struct __has_const_void_pointer<_Tp, |
| typename __void_t<typename _Tp::const_void_pointer>::type> : true_type {}; |
| |
| template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value> |
| struct __const_void_pointer |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::const_void_pointer type; |
| }; |
| |
| template <class _Ptr, class _Alloc> |
| struct __const_void_pointer<_Ptr, _Alloc, false> |
| { |
| #ifndef _LIBCPP_CXX03_LANG |
| typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::template rebind<const void> type; |
| #else |
| typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::template rebind<const void>::other type; |
| #endif |
| }; |
| |
| template <class _Tp, class = void> |
| struct __has_size_type : false_type {}; |
| |
| template <class _Tp> |
| struct __has_size_type<_Tp, |
| typename __void_t<typename _Tp::size_type>::type> : true_type {}; |
| |
| template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value> |
| struct __size_type |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename make_unsigned<_DiffType>::type type; |
| }; |
| |
| template <class _Alloc, class _DiffType> |
| struct __size_type<_Alloc, _DiffType, true> |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::size_type type; |
| }; |
| |
| template <class _Tp, class = void> |
| struct __has_propagate_on_container_copy_assignment : false_type {}; |
| |
| template <class _Tp> |
| struct __has_propagate_on_container_copy_assignment<_Tp, |
| typename __void_t<typename _Tp::propagate_on_container_copy_assignment>::type> |
| : true_type {}; |
| |
| template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_Alloc>::value> |
| struct __propagate_on_container_copy_assignment |
| { |
| typedef _LIBCPP_NODEBUG_TYPE false_type type; |
| }; |
| |
| template <class _Alloc> |
| struct __propagate_on_container_copy_assignment<_Alloc, true> |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::propagate_on_container_copy_assignment type; |
| }; |
| |
| template <class _Tp, class = void> |
| struct __has_propagate_on_container_move_assignment : false_type {}; |
| |
| template <class _Tp> |
| struct __has_propagate_on_container_move_assignment<_Tp, |
| typename __void_t<typename _Tp::propagate_on_container_move_assignment>::type> |
| : true_type {}; |
| |
| template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value> |
| struct __propagate_on_container_move_assignment |
| { |
| typedef false_type type; |
| }; |
| |
| template <class _Alloc> |
| struct __propagate_on_container_move_assignment<_Alloc, true> |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::propagate_on_container_move_assignment type; |
| }; |
| |
| template <class _Tp, class = void> |
| struct __has_propagate_on_container_swap : false_type {}; |
| |
| template <class _Tp> |
| struct __has_propagate_on_container_swap<_Tp, |
| typename __void_t<typename _Tp::propagate_on_container_swap>::type> |
| : true_type {}; |
| |
| template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value> |
| struct __propagate_on_container_swap |
| { |
| typedef false_type type; |
| }; |
| |
| template <class _Alloc> |
| struct __propagate_on_container_swap<_Alloc, true> |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::propagate_on_container_swap type; |
| }; |
| |
| template <class _Tp, class = void> |
| struct __has_is_always_equal : false_type {}; |
| |
| template <class _Tp> |
| struct __has_is_always_equal<_Tp, |
| typename __void_t<typename _Tp::is_always_equal>::type> |
| : true_type {}; |
| |
| template <class _Alloc, bool = __has_is_always_equal<_Alloc>::value> |
| struct __is_always_equal |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename _VSTD::is_empty<_Alloc>::type type; |
| }; |
| |
| template <class _Alloc> |
| struct __is_always_equal<_Alloc, true> |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::is_always_equal type; |
| }; |
| |
| template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value> |
| struct __has_rebind_other |
| { |
| private: |
| struct __two {char __lx; char __lxx;}; |
| template <class _Xp> static __two __test(...); |
| _LIBCPP_SUPPRESS_DEPRECATED_PUSH |
| template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0); |
| _LIBCPP_SUPPRESS_DEPRECATED_POP |
| public: |
| static const bool value = sizeof(__test<_Tp>(0)) == 1; |
| }; |
| |
| template <class _Tp, class _Up> |
| struct __has_rebind_other<_Tp, _Up, false> |
| { |
| static const bool value = false; |
| }; |
| |
| template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value> |
| struct __allocator_traits_rebind |
| { |
| _LIBCPP_SUPPRESS_DEPRECATED_PUSH |
| typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type; |
| _LIBCPP_SUPPRESS_DEPRECATED_POP |
| }; |
| |
| template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up> |
| struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true> |
| { |
| _LIBCPP_SUPPRESS_DEPRECATED_PUSH |
| typedef _LIBCPP_NODEBUG_TYPE typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type; |
| _LIBCPP_SUPPRESS_DEPRECATED_POP |
| }; |
| |
| template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up> |
| struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false> |
| { |
| typedef _LIBCPP_NODEBUG_TYPE _Alloc<_Up, _Args...> type; |
| }; |
| |
| #ifndef _LIBCPP_CXX03_LANG |
| |
| _LIBCPP_SUPPRESS_DEPRECATED_PUSH |
| template <class _Alloc, class _SizeType, class _ConstVoidPtr> |
| auto |
| __has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p) |
| -> decltype((void)__a.allocate(__sz, __p), true_type()); |
| _LIBCPP_SUPPRESS_DEPRECATED_POP |
| |
| template <class _Alloc, class _SizeType, class _ConstVoidPtr> |
| auto |
| __has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __p) |
| -> false_type; |
| |
| template <class _Alloc, class _SizeType, class _ConstVoidPtr> |
| struct __has_allocate_hint |
| : decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(), |
| declval<_SizeType>(), |
| declval<_ConstVoidPtr>())) |
| { |
| }; |
| |
| #else // _LIBCPP_CXX03_LANG |
| |
| template <class _Alloc, class _SizeType, class _ConstVoidPtr> |
| struct __has_allocate_hint |
| : true_type |
| { |
| }; |
| |
| #endif // _LIBCPP_CXX03_LANG |
| |
| _LIBCPP_SUPPRESS_DEPRECATED_PUSH |
| template <class _Alloc, class ..._Args, |
| class = decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Args>()...))> |
| static true_type __test_has_construct(int); |
| _LIBCPP_SUPPRESS_DEPRECATED_POP |
| |
| template <class _Alloc, class...> |
| static false_type __test_has_construct(...); |
| |
| template <class _Alloc, class ..._Args> |
| struct __has_construct : decltype(__test_has_construct<_Alloc, _Args...>(0)) {}; |
| |
| #if !defined(_LIBCPP_CXX03_LANG) |
| |
| _LIBCPP_SUPPRESS_DEPRECATED_PUSH |
| template <class _Alloc, class _Pointer> |
| auto |
| __has_destroy_test(_Alloc&& __a, _Pointer&& __p) |
| -> decltype(__a.destroy(__p), true_type()); |
| _LIBCPP_SUPPRESS_DEPRECATED_POP |
| |
| template <class _Alloc, class _Pointer> |
| auto |
| __has_destroy_test(const _Alloc& __a, _Pointer&& __p) |
| -> false_type; |
| |
| template <class _Alloc, class _Pointer> |
| struct __has_destroy |
| : decltype(_VSTD::__has_destroy_test(declval<_Alloc>(), |
| declval<_Pointer>())) |
| { |
| }; |
| |
| _LIBCPP_SUPPRESS_DEPRECATED_PUSH |
| template <class _Alloc> |
| auto |
| __has_max_size_test(_Alloc&& __a) |
| -> decltype(__a.max_size(), true_type()); |
| _LIBCPP_SUPPRESS_DEPRECATED_POP |
| |
| template <class _Alloc> |
| auto |
| __has_max_size_test(const volatile _Alloc& __a) |
| -> false_type; |
| |
| template <class _Alloc> |
| struct __has_max_size |
| : decltype(_VSTD::__has_max_size_test(declval<_Alloc&>())) |
| { |
| }; |
| |
| template <class _Alloc> |
| auto |
| __has_select_on_container_copy_construction_test(_Alloc&& __a) |
| -> decltype(__a.select_on_container_copy_construction(), true_type()); |
| |
| template <class _Alloc> |
| auto |
| __has_select_on_container_copy_construction_test(const volatile _Alloc& __a) |
| -> false_type; |
| |
| template <class _Alloc> |
| struct __has_select_on_container_copy_construction |
| : decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>())) |
| { |
| }; |
| |
| #else // _LIBCPP_CXX03_LANG |
| |
| template <class _Alloc, class _Pointer, class = void> |
| struct __has_destroy : false_type {}; |
| |
| template <class _Alloc, class _Pointer> |
| struct __has_destroy<_Alloc, _Pointer, typename __void_t< |
| decltype(_VSTD::declval<_Alloc>().destroy(_VSTD::declval<_Pointer>())) |
| >::type> : true_type {}; |
| |
| template <class _Alloc> |
| struct __has_max_size |
| : true_type |
| { |
| }; |
| |
| template <class _Alloc> |
| struct __has_select_on_container_copy_construction |
| : false_type |
| { |
| }; |
| |
| #endif // _LIBCPP_CXX03_LANG |
| |
| template <class _Alloc, class _Ptr, bool = __has_difference_type<_Alloc>::value> |
| struct __alloc_traits_difference_type |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename pointer_traits<_Ptr>::difference_type type; |
| }; |
| |
| template <class _Alloc, class _Ptr> |
| struct __alloc_traits_difference_type<_Alloc, _Ptr, true> |
| { |
| typedef _LIBCPP_NODEBUG_TYPE typename _Alloc::difference_type type; |
| }; |
| |
| template <class _Tp> |
| struct __is_default_allocator : false_type {}; |
| |
| template <class _Tp> |
| struct __is_default_allocator<_VSTD::allocator<_Tp> > : true_type {}; |
| |
| |
| |
| template <class _Alloc, |
| bool = __has_construct<_Alloc, typename _Alloc::value_type*, typename _Alloc::value_type&&>::value && !__is_default_allocator<_Alloc>::value |
| > |
| struct __is_cpp17_move_insertable; |
| template <class _Alloc> |
| struct __is_cpp17_move_insertable<_Alloc, true> : true_type {}; |
| template <class _Alloc> |
| struct __is_cpp17_move_insertable<_Alloc, false> : is_move_constructible<typename _Alloc::value_type> {}; |
| |
| template <class _Alloc, |
| bool = __has_construct<_Alloc, typename _Alloc::value_type*, const typename _Alloc::value_type&>::value && !__is_default_allocator<_Alloc>::value |
| > |
| struct __is_cpp17_copy_insertable; |
| template <class _Alloc> |
| struct __is_cpp17_copy_insertable<_Alloc, true> : __is_cpp17_move_insertable<_Alloc> {}; |
| template <class _Alloc> |
| struct __is_cpp17_copy_insertable<_Alloc, false> : integral_constant<bool, |
| is_copy_constructible<typename _Alloc::value_type>::value && |
| __is_cpp17_move_insertable<_Alloc>::value> |
| {}; |
| |
| |
| |
| template <class _Alloc> |
| struct _LIBCPP_TEMPLATE_VIS allocator_traits |
| { |
| typedef _Alloc allocator_type; |
| typedef typename allocator_type::value_type value_type; |
| |
| typedef typename __pointer_type<value_type, allocator_type>::type pointer; |
| typedef typename __const_pointer<value_type, pointer, allocator_type>::type const_pointer; |
| typedef typename __void_pointer<pointer, allocator_type>::type void_pointer; |
| typedef typename __const_void_pointer<pointer, allocator_type>::type const_void_pointer; |
| |
| typedef typename __alloc_traits_difference_type<allocator_type, pointer>::type difference_type; |
| typedef typename __size_type<allocator_type, difference_type>::type size_type; |
| |
| typedef typename __propagate_on_container_copy_assignment<allocator_type>::type |
| propagate_on_container_copy_assignment; |
| typedef typename __propagate_on_container_move_assignment<allocator_type>::type |
| propagate_on_container_move_assignment; |
| typedef typename __propagate_on_container_swap<allocator_type>::type |
| propagate_on_container_swap; |
| typedef typename __is_always_equal<allocator_type>::type |
| is_always_equal; |
| |
| #ifndef _LIBCPP_CXX03_LANG |
| template <class _Tp> using rebind_alloc = |
| typename __allocator_traits_rebind<allocator_type, _Tp>::type; |
| template <class _Tp> using rebind_traits = allocator_traits<rebind_alloc<_Tp> >; |
| #else // _LIBCPP_CXX03_LANG |
| template <class _Tp> struct rebind_alloc |
| {typedef typename __allocator_traits_rebind<allocator_type, _Tp>::type other;}; |
| template <class _Tp> struct rebind_traits |
| {typedef allocator_traits<typename rebind_alloc<_Tp>::other> other;}; |
| #endif // _LIBCPP_CXX03_LANG |
| |
| _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static pointer allocate(allocator_type& __a, size_type __n) |
| {return __a.allocate(__n);} |
| _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) |
| {return __allocate(__a, __n, __hint, |
| __has_allocate_hint<allocator_type, size_type, const_void_pointer>());} |
| |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT |
| {__a.deallocate(__p, __n);} |
| |
| template <class _Tp, class... _Args> |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args) |
| {__construct(__has_construct<allocator_type, _Tp*, _Args...>(), |
| __a, __p, _VSTD::forward<_Args>(__args)...);} |
| |
| template <class _Tp> |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static void destroy(allocator_type& __a, _Tp* __p) |
| {__destroy(__has_destroy<allocator_type, _Tp*>(), __a, __p);} |
| |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static size_type max_size(const allocator_type& __a) _NOEXCEPT |
| {return __max_size(__has_max_size<const allocator_type>(), __a);} |
| |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static allocator_type |
| select_on_container_copy_construction(const allocator_type& __a) |
| {return __select_on_container_copy_construction( |
| __has_select_on_container_copy_construction<const allocator_type>(), |
| __a);} |
| |
| private: |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static pointer __allocate(allocator_type& __a, size_type __n, |
| const_void_pointer __hint, true_type) |
| { |
| _LIBCPP_SUPPRESS_DEPRECATED_PUSH |
| return __a.allocate(__n, __hint); |
| _LIBCPP_SUPPRESS_DEPRECATED_POP |
| } |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static pointer __allocate(allocator_type& __a, size_type __n, |
| const_void_pointer, false_type) |
| {return __a.allocate(__n);} |
| |
| template <class _Tp, class... _Args> |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args) |
| { |
| _LIBCPP_SUPPRESS_DEPRECATED_PUSH |
| __a.construct(__p, _VSTD::forward<_Args>(__args)...); |
| _LIBCPP_SUPPRESS_DEPRECATED_POP |
| } |
| |
| template <class _Tp, class... _Args> |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args) |
| { |
| #if _LIBCPP_STD_VER > 17 |
| _VSTD::construct_at(__p, _VSTD::forward<_Args>(__args)...); |
| #else |
| ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...); |
| #endif |
| } |
| |
| template <class _Tp> |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static void __destroy(true_type, allocator_type& __a, _Tp* __p) |
| { |
| _LIBCPP_SUPPRESS_DEPRECATED_PUSH |
| __a.destroy(__p); |
| _LIBCPP_SUPPRESS_DEPRECATED_POP |
| } |
| template <class _Tp> |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static void __destroy(false_type, allocator_type&, _Tp* __p) |
| { |
| #if _LIBCPP_STD_VER > 17 |
| _VSTD::destroy_at(__p); |
| #else |
| __p->~_Tp(); |
| #endif |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static size_type __max_size(true_type, const allocator_type& __a) _NOEXCEPT |
| { |
| _LIBCPP_SUPPRESS_DEPRECATED_PUSH |
| return __a.max_size(); |
| _LIBCPP_SUPPRESS_DEPRECATED_POP |
| } |
| |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static size_type __max_size(false_type, const allocator_type&) _NOEXCEPT |
| {return numeric_limits<size_type>::max() / sizeof(value_type);} |
| |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static allocator_type |
| __select_on_container_copy_construction(true_type, const allocator_type& __a) |
| {return __a.select_on_container_copy_construction();} |
| _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 |
| static allocator_type |
| __select_on_container_copy_construction(false_type, const allocator_type& __a) |
| {return __a;} |
| }; |
| |
| template <class _Traits, class _Tp> |
| struct __rebind_alloc_helper |
| { |
| #ifndef _LIBCPP_CXX03_LANG |
| typedef _LIBCPP_NODEBUG_TYPE typename _Traits::template rebind_alloc<_Tp> type; |
| #else |
| typedef typename _Traits::template rebind_alloc<_Tp>::other type; |
| #endif |
| }; |
| |
| _LIBCPP_END_NAMESPACE_STD |
| |
| _LIBCPP_POP_MACROS |
| |
| #endif // _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H |