forked from OSchip/llvm-project
414 lines
16 KiB
C++
414 lines
16 KiB
C++
// -*- 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/construct_at.h>
|
|
#include <__memory/pointer_traits.h>
|
|
#include <__utility/forward.h>
|
|
#include <limits>
|
|
#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
|
|
|
|
#define _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(NAME, PROPERTY) \
|
|
template <class _Tp, class = void> struct NAME : false_type { }; \
|
|
template <class _Tp> struct NAME<_Tp, typename __void_t<typename _Tp:: PROPERTY >::type> : true_type { }
|
|
|
|
// __pointer
|
|
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_pointer, pointer);
|
|
template <class _Tp, class _Alloc,
|
|
class _RawAlloc = typename remove_reference<_Alloc>::type,
|
|
bool = __has_pointer<_RawAlloc>::value>
|
|
struct __pointer {
|
|
using type _LIBCPP_NODEBUG = typename _RawAlloc::pointer;
|
|
};
|
|
template <class _Tp, class _Alloc, class _RawAlloc>
|
|
struct __pointer<_Tp, _Alloc, _RawAlloc, false> {
|
|
using type _LIBCPP_NODEBUG = _Tp*;
|
|
};
|
|
|
|
// __const_pointer
|
|
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_const_pointer, const_pointer);
|
|
template <class _Tp, class _Ptr, class _Alloc,
|
|
bool = __has_const_pointer<_Alloc>::value>
|
|
struct __const_pointer {
|
|
using type _LIBCPP_NODEBUG = typename _Alloc::const_pointer;
|
|
};
|
|
template <class _Tp, class _Ptr, class _Alloc>
|
|
struct __const_pointer<_Tp, _Ptr, _Alloc, false> {
|
|
#ifdef _LIBCPP_CXX03_LANG
|
|
using type = typename pointer_traits<_Ptr>::template rebind<const _Tp>::other;
|
|
#else
|
|
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const _Tp>;
|
|
#endif
|
|
};
|
|
|
|
// __void_pointer
|
|
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_void_pointer, void_pointer);
|
|
template <class _Ptr, class _Alloc,
|
|
bool = __has_void_pointer<_Alloc>::value>
|
|
struct __void_pointer {
|
|
using type _LIBCPP_NODEBUG = typename _Alloc::void_pointer;
|
|
};
|
|
template <class _Ptr, class _Alloc>
|
|
struct __void_pointer<_Ptr, _Alloc, false> {
|
|
#ifdef _LIBCPP_CXX03_LANG
|
|
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<void>::other;
|
|
#else
|
|
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<void>;
|
|
#endif
|
|
};
|
|
|
|
// __const_void_pointer
|
|
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_const_void_pointer, const_void_pointer);
|
|
template <class _Ptr, class _Alloc,
|
|
bool = __has_const_void_pointer<_Alloc>::value>
|
|
struct __const_void_pointer {
|
|
using type _LIBCPP_NODEBUG = typename _Alloc::const_void_pointer;
|
|
};
|
|
template <class _Ptr, class _Alloc>
|
|
struct __const_void_pointer<_Ptr, _Alloc, false> {
|
|
#ifdef _LIBCPP_CXX03_LANG
|
|
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const void>::other;
|
|
#else
|
|
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const void>;
|
|
#endif
|
|
};
|
|
|
|
// __size_type
|
|
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_size_type, size_type);
|
|
template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value>
|
|
struct __size_type : make_unsigned<_DiffType> { };
|
|
template <class _Alloc, class _DiffType>
|
|
struct __size_type<_Alloc, _DiffType, true> {
|
|
using type _LIBCPP_NODEBUG = typename _Alloc::size_type;
|
|
};
|
|
|
|
// __alloc_traits_difference_type
|
|
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_alloc_traits_difference_type, difference_type);
|
|
template <class _Alloc, class _Ptr, bool = __has_alloc_traits_difference_type<_Alloc>::value>
|
|
struct __alloc_traits_difference_type {
|
|
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::difference_type;
|
|
};
|
|
template <class _Alloc, class _Ptr>
|
|
struct __alloc_traits_difference_type<_Alloc, _Ptr, true> {
|
|
using type _LIBCPP_NODEBUG = typename _Alloc::difference_type;
|
|
};
|
|
|
|
// __propagate_on_container_copy_assignment
|
|
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_copy_assignment, propagate_on_container_copy_assignment);
|
|
template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_Alloc>::value>
|
|
struct __propagate_on_container_copy_assignment : false_type { };
|
|
template <class _Alloc>
|
|
struct __propagate_on_container_copy_assignment<_Alloc, true> {
|
|
using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_copy_assignment;
|
|
};
|
|
|
|
// __propagate_on_container_move_assignment
|
|
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_move_assignment, propagate_on_container_move_assignment);
|
|
template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value>
|
|
struct __propagate_on_container_move_assignment : false_type { };
|
|
template <class _Alloc>
|
|
struct __propagate_on_container_move_assignment<_Alloc, true> {
|
|
using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_move_assignment;
|
|
};
|
|
|
|
// __propagate_on_container_swap
|
|
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_swap, propagate_on_container_swap);
|
|
template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value>
|
|
struct __propagate_on_container_swap : false_type { };
|
|
template <class _Alloc>
|
|
struct __propagate_on_container_swap<_Alloc, true> {
|
|
using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_swap;
|
|
};
|
|
|
|
// __is_always_equal
|
|
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_is_always_equal, is_always_equal);
|
|
template <class _Alloc, bool = __has_is_always_equal<_Alloc>::value>
|
|
struct __is_always_equal : is_empty<_Alloc> { };
|
|
template <class _Alloc>
|
|
struct __is_always_equal<_Alloc, true> {
|
|
using type _LIBCPP_NODEBUG = typename _Alloc::is_always_equal;
|
|
};
|
|
|
|
// __allocator_traits_rebind
|
|
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
|
|
template <class _Tp, class _Up, class = void>
|
|
struct __has_rebind_other : false_type { };
|
|
template <class _Tp, class _Up>
|
|
struct __has_rebind_other<_Tp, _Up, typename __void_t<
|
|
typename _Tp::template rebind<_Up>::other
|
|
>::type> : true_type { };
|
|
|
|
template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
|
|
struct __allocator_traits_rebind {
|
|
using type _LIBCPP_NODEBUG = typename _Tp::template rebind<_Up>::other;
|
|
};
|
|
template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
|
|
struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true> {
|
|
using type _LIBCPP_NODEBUG = typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other;
|
|
};
|
|
template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
|
|
struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false> {
|
|
using type _LIBCPP_NODEBUG = _Alloc<_Up, _Args...>;
|
|
};
|
|
_LIBCPP_SUPPRESS_DEPRECATED_POP
|
|
|
|
template<class _Alloc, class _Tp>
|
|
using __allocator_traits_rebind_t = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
|
|
|
|
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
|
|
|
|
// __has_allocate_hint
|
|
template <class _Alloc, class _SizeType, class _ConstVoidPtr, class = void>
|
|
struct __has_allocate_hint : false_type { };
|
|
|
|
template <class _Alloc, class _SizeType, class _ConstVoidPtr>
|
|
struct __has_allocate_hint<_Alloc, _SizeType, _ConstVoidPtr, decltype(
|
|
(void)declval<_Alloc>().allocate(declval<_SizeType>(), declval<_ConstVoidPtr>())
|
|
)> : true_type { };
|
|
|
|
// __has_construct
|
|
template <class, class _Alloc, class ..._Args>
|
|
struct __has_construct_impl : false_type { };
|
|
|
|
template <class _Alloc, class ..._Args>
|
|
struct __has_construct_impl<decltype(
|
|
(void)declval<_Alloc>().construct(declval<_Args>()...)
|
|
), _Alloc, _Args...> : true_type { };
|
|
|
|
template <class _Alloc, class ..._Args>
|
|
struct __has_construct : __has_construct_impl<void, _Alloc, _Args...> { };
|
|
|
|
// __has_destroy
|
|
template <class _Alloc, class _Pointer, class = void>
|
|
struct __has_destroy : false_type { };
|
|
|
|
template <class _Alloc, class _Pointer>
|
|
struct __has_destroy<_Alloc, _Pointer, decltype(
|
|
(void)declval<_Alloc>().destroy(declval<_Pointer>())
|
|
)> : true_type { };
|
|
|
|
// __has_max_size
|
|
template <class _Alloc, class = void>
|
|
struct __has_max_size : false_type { };
|
|
|
|
template <class _Alloc>
|
|
struct __has_max_size<_Alloc, decltype(
|
|
(void)declval<_Alloc&>().max_size()
|
|
)> : true_type { };
|
|
|
|
// __has_select_on_container_copy_construction
|
|
template <class _Alloc, class = void>
|
|
struct __has_select_on_container_copy_construction : false_type { };
|
|
|
|
template <class _Alloc>
|
|
struct __has_select_on_container_copy_construction<_Alloc, decltype(
|
|
(void)declval<_Alloc>().select_on_container_copy_construction()
|
|
)> : true_type { };
|
|
|
|
_LIBCPP_SUPPRESS_DEPRECATED_POP
|
|
|
|
template <class _Alloc>
|
|
struct _LIBCPP_TEMPLATE_VIS allocator_traits
|
|
{
|
|
using allocator_type = _Alloc;
|
|
using value_type = typename allocator_type::value_type;
|
|
using pointer = typename __pointer<value_type, allocator_type>::type;
|
|
using const_pointer = typename __const_pointer<value_type, pointer, allocator_type>::type;
|
|
using void_pointer = typename __void_pointer<pointer, allocator_type>::type;
|
|
using const_void_pointer = typename __const_void_pointer<pointer, allocator_type>::type;
|
|
using difference_type = typename __alloc_traits_difference_type<allocator_type, pointer>::type;
|
|
using size_type = typename __size_type<allocator_type, difference_type>::type;
|
|
using propagate_on_container_copy_assignment = typename __propagate_on_container_copy_assignment<allocator_type>::type;
|
|
using propagate_on_container_move_assignment = typename __propagate_on_container_move_assignment<allocator_type>::type;
|
|
using propagate_on_container_swap = typename __propagate_on_container_swap<allocator_type>::type;
|
|
using is_always_equal = typename __is_always_equal<allocator_type>::type;
|
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
|
template <class _Tp>
|
|
using rebind_alloc = __allocator_traits_rebind_t<allocator_type, _Tp>;
|
|
template <class _Tp>
|
|
using rebind_traits = allocator_traits<rebind_alloc<_Tp> >;
|
|
#else // _LIBCPP_CXX03_LANG
|
|
template <class _Tp>
|
|
struct rebind_alloc {
|
|
using other = __allocator_traits_rebind_t<allocator_type, _Tp>;
|
|
};
|
|
template <class _Tp>
|
|
struct rebind_traits {
|
|
using other = allocator_traits<typename rebind_alloc<_Tp>::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);
|
|
}
|
|
|
|
template <class _Ap = _Alloc, class =
|
|
__enable_if_t<__has_allocate_hint<_Ap, size_type, const_void_pointer>::value> >
|
|
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) {
|
|
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
|
|
return __a.allocate(__n, __hint);
|
|
_LIBCPP_SUPPRESS_DEPRECATED_POP
|
|
}
|
|
template <class _Ap = _Alloc, class = void, class =
|
|
__enable_if_t<!__has_allocate_hint<_Ap, size_type, const_void_pointer>::value> >
|
|
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer) {
|
|
return __a.allocate(__n);
|
|
}
|
|
|
|
_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, class =
|
|
__enable_if_t<__has_construct<allocator_type, _Tp*, _Args...>::value> >
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
static void construct(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, class = void, class =
|
|
__enable_if_t<!__has_construct<allocator_type, _Tp*, _Args...>::value> >
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
static void construct(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, class =
|
|
__enable_if_t<__has_destroy<allocator_type, _Tp*>::value> >
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
static void destroy(allocator_type& __a, _Tp* __p) {
|
|
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
|
|
__a.destroy(__p);
|
|
_LIBCPP_SUPPRESS_DEPRECATED_POP
|
|
}
|
|
template <class _Tp, class = void, class =
|
|
__enable_if_t<!__has_destroy<allocator_type, _Tp*>::value> >
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
static void destroy(allocator_type&, _Tp* __p) {
|
|
#if _LIBCPP_STD_VER > 17
|
|
_VSTD::destroy_at(__p);
|
|
#else
|
|
__p->~_Tp();
|
|
#endif
|
|
}
|
|
|
|
template <class _Ap = _Alloc, class =
|
|
__enable_if_t<__has_max_size<const _Ap>::value> >
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
static size_type max_size(const allocator_type& __a) _NOEXCEPT {
|
|
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
|
|
return __a.max_size();
|
|
_LIBCPP_SUPPRESS_DEPRECATED_POP
|
|
}
|
|
template <class _Ap = _Alloc, class = void, class =
|
|
__enable_if_t<!__has_max_size<const _Ap>::value> >
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
static size_type max_size(const allocator_type&) _NOEXCEPT {
|
|
return numeric_limits<size_type>::max() / sizeof(value_type);
|
|
}
|
|
|
|
template <class _Ap = _Alloc, class =
|
|
__enable_if_t<__has_select_on_container_copy_construction<const _Ap>::value> >
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
static allocator_type select_on_container_copy_construction(const allocator_type& __a) {
|
|
return __a.select_on_container_copy_construction();
|
|
}
|
|
template <class _Ap = _Alloc, class = void, class =
|
|
__enable_if_t<!__has_select_on_container_copy_construction<const _Ap>::value> >
|
|
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
|
|
static allocator_type select_on_container_copy_construction(const allocator_type& __a) {
|
|
return __a;
|
|
}
|
|
};
|
|
|
|
// A version of `allocator_traits` for internal usage that SFINAEs away if the
|
|
// given allocator doesn't have a nested `value_type`. This helps avoid hard
|
|
// errors when forming implicit deduction guides for a container that has an
|
|
// invalid Allocator type. See https://wg21.link/LWGXXXXX.
|
|
// TODO(varconst): use the actual link once available.
|
|
template <class _Alloc, class _ValueType = typename _Alloc::value_type>
|
|
struct _LIBCPP_TEMPLATE_VIS __allocator_traits : allocator_traits<_Alloc> {};
|
|
|
|
template <class _Traits, class _Tp>
|
|
struct __rebind_alloc_helper {
|
|
#ifndef _LIBCPP_CXX03_LANG
|
|
using type _LIBCPP_NODEBUG = typename _Traits::template rebind_alloc<_Tp>;
|
|
#else
|
|
using type = typename _Traits::template rebind_alloc<_Tp>::other;
|
|
#endif
|
|
};
|
|
|
|
// __is_default_allocator
|
|
template <class _Tp>
|
|
struct __is_default_allocator : false_type { };
|
|
|
|
template <class> class allocator;
|
|
|
|
template <class _Tp>
|
|
struct __is_default_allocator<allocator<_Tp> > : true_type { };
|
|
|
|
// __is_cpp17_move_insertable
|
|
template <class _Alloc, class = void>
|
|
struct __is_cpp17_move_insertable
|
|
: is_move_constructible<typename _Alloc::value_type>
|
|
{ };
|
|
|
|
template <class _Alloc>
|
|
struct __is_cpp17_move_insertable<_Alloc, __enable_if_t<
|
|
!__is_default_allocator<_Alloc>::value &&
|
|
__has_construct<_Alloc, typename _Alloc::value_type*, typename _Alloc::value_type&&>::value
|
|
> > : true_type { };
|
|
|
|
// __is_cpp17_copy_insertable
|
|
template <class _Alloc, class = void>
|
|
struct __is_cpp17_copy_insertable
|
|
: integral_constant<bool,
|
|
is_copy_constructible<typename _Alloc::value_type>::value &&
|
|
__is_cpp17_move_insertable<_Alloc>::value
|
|
>
|
|
{ };
|
|
|
|
template <class _Alloc>
|
|
struct __is_cpp17_copy_insertable<_Alloc, __enable_if_t<
|
|
!__is_default_allocator<_Alloc>::value &&
|
|
__has_construct<_Alloc, typename _Alloc::value_type*, const typename _Alloc::value_type&>::value
|
|
> >
|
|
: __is_cpp17_move_insertable<_Alloc>
|
|
{ };
|
|
|
|
#undef _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
_LIBCPP_POP_MACROS
|
|
|
|
#endif // _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H
|