maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libcxx/include/__memory/allocator_traits.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

406 lines
16 KiB
C
Raw Normal View History

[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
// -*- 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>
[libc++] Split up __memory/base.h into meaningful headers
2021-04-15 01:59:03 +08:00
#include <__memory/construct_at.h>
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#include <__memory/pointer_traits.h>
[libcxx][modularisation] moves <utility> content out of <type_traits> Moves: * `std::move`, `std::forward`, `std::declval`, and `std::swap` into `__utility/${FUNCTION_NAME}`. * `std::swap_ranges` and `std::iter_swap` into `__algorithm/${FUNCTION_NAME}` Differential Revision: https://reviews.llvm.org/D103734
2021-06-05 10:47:47 +08:00
#include <__utility/forward.h>
[libc++] NFC: Move unused include of <limits> to allocator_traits.h The include should have been moved when I split allocator_traits.h out of memory.
2021-04-10 03:19:42 +08:00
#include <limits>
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#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
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
#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_TYPE = typename _RawAlloc::pointer;
};
template <class _Tp, class _Alloc, class _RawAlloc>
struct __pointer<_Tp, _Alloc, _RawAlloc, false> {
using type _LIBCPP_NODEBUG_TYPE = _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_TYPE = typename _Alloc::const_pointer;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
template <class _Tp, class _Ptr, class _Alloc>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __const_pointer<_Tp, _Ptr, _Alloc, false> {
#ifdef _LIBCPP_CXX03_LANG
using type = typename pointer_traits<_Ptr>::template rebind<const _Tp>::other;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#else
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
using type _LIBCPP_NODEBUG_TYPE = typename pointer_traits<_Ptr>::template rebind<const _Tp>;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#endif
};
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __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_TYPE = typename _Alloc::void_pointer;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
template <class _Ptr, class _Alloc>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __void_pointer<_Ptr, _Alloc, false> {
#ifdef _LIBCPP_CXX03_LANG
using type _LIBCPP_NODEBUG_TYPE = typename pointer_traits<_Ptr>::template rebind<void>::other;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#else
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
using type _LIBCPP_NODEBUG_TYPE = typename pointer_traits<_Ptr>::template rebind<void>;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#endif
};
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __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_TYPE = typename _Alloc::const_void_pointer;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
template <class _Ptr, class _Alloc>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __const_void_pointer<_Ptr, _Alloc, false> {
#ifdef _LIBCPP_CXX03_LANG
using type _LIBCPP_NODEBUG_TYPE = typename pointer_traits<_Ptr>::template rebind<const void>::other;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#else
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
using type _LIBCPP_NODEBUG_TYPE = typename pointer_traits<_Ptr>::template rebind<const void>;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#endif
};
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __size_type
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_size_type, size_type);
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __size_type : make_unsigned<_DiffType> { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc, class _DiffType>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __size_type<_Alloc, _DiffType, true> {
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::size_type;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __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_TYPE = typename pointer_traits<_Ptr>::difference_type;
};
template <class _Alloc, class _Ptr>
struct __alloc_traits_difference_type<_Alloc, _Ptr, true> {
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::difference_type;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __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 { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __propagate_on_container_copy_assignment<_Alloc, true> {
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::propagate_on_container_copy_assignment;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __propagate_on_container_move_assignment
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_move_assignment, propagate_on_container_move_assignment);
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __propagate_on_container_move_assignment : false_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __propagate_on_container_move_assignment<_Alloc, true> {
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::propagate_on_container_move_assignment;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __propagate_on_container_swap
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_swap, propagate_on_container_swap);
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __propagate_on_container_swap : false_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __propagate_on_container_swap<_Alloc, true> {
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::propagate_on_container_swap;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __is_always_equal
_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_is_always_equal, is_always_equal);
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc, bool = __has_is_always_equal<_Alloc>::value>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __is_always_equal : is_empty<_Alloc> { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __is_always_equal<_Alloc, true> {
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc::is_always_equal;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __allocator_traits_rebind
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
template <class _Tp, class _Up, class = void>
struct __has_rebind_other : false_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Tp, class _Up>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __has_rebind_other<_Tp, _Up, typename __void_t<
typename _Tp::template rebind<_Up>::other
>::type> : true_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __allocator_traits_rebind {
using type _LIBCPP_NODEBUG_TYPE = typename _Tp::template rebind<_Up>::other;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true> {
using type _LIBCPP_NODEBUG_TYPE = typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false> {
using type _LIBCPP_NODEBUG_TYPE = _Alloc<_Up, _Args...>;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
_LIBCPP_SUPPRESS_DEPRECATED_POP
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
template<class _Alloc, class _Tp>
using __allocator_traits_rebind_t = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __has_allocate_hint
template <class _Alloc, class _SizeType, class _ConstVoidPtr, class = void>
struct __has_allocate_hint : false_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc, class _SizeType, class _ConstVoidPtr>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __has_allocate_hint<_Alloc, _SizeType, _ConstVoidPtr, decltype(
(void)declval<_Alloc>().allocate(declval<_SizeType>(), declval<_ConstVoidPtr>())
)> : true_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __has_construct
template <class, class _Alloc, class ..._Args>
struct __has_construct_impl : false_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc, class ..._Args>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __has_construct_impl<decltype(
(void)declval<_Alloc>().construct(declval<_Args>()...)
), _Alloc, _Args...> : true_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
template <class _Alloc, class ..._Args>
struct __has_construct : __has_construct_impl<void, _Alloc, _Args...> { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __has_destroy
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc, class _Pointer, class = void>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __has_destroy : false_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc, class _Pointer>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __has_destroy<_Alloc, _Pointer, decltype(
(void)declval<_Alloc>().destroy(declval<_Pointer>())
)> : true_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __has_max_size
template <class _Alloc, class = void>
struct __has_max_size : false_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __has_max_size<_Alloc, decltype(
(void)declval<_Alloc&>().max_size()
)> : true_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __has_select_on_container_copy_construction
template <class _Alloc, class = void>
struct __has_select_on_container_copy_construction : false_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __has_select_on_container_copy_construction<_Alloc, decltype(
(void)declval<_Alloc>().select_on_container_copy_construction()
)> : true_type { };
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
_LIBCPP_SUPPRESS_DEPRECATED_POP
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
template <class _Alloc>
struct _LIBCPP_TEMPLATE_VIS allocator_traits
{
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
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;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#ifndef _LIBCPP_CXX03_LANG
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
template <class _Tp>
using rebind_alloc = __allocator_traits_rebind_t<allocator_type, _Tp>;
template <class _Tp>
using rebind_traits = allocator_traits<rebind_alloc<_Tp> >;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#else // _LIBCPP_CXX03_LANG
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
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>;
};
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // _LIBCPP_CXX03_LANG
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
static pointer allocate(allocator_type& __a, size_type __n) {
return __a.allocate(__n);
}
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
template <class _Ap = _Alloc, class =
_EnableIf<__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 =
_EnableIf<!__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);
}
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT {
__a.deallocate(__p, __n);
}
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
template <class _Tp, class... _Args, class =
_EnableIf<__has_construct<allocator_type, _Tp*, _Args...>::value> >
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
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 =
_EnableIf<!__has_construct<allocator_type, _Tp*, _Args...>::value> >
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
static void construct(allocator_type&, _Tp* __p, _Args&&... __args) {
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#if _LIBCPP_STD_VER > 17
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
_VSTD::construct_at(__p, _VSTD::forward<_Args>(__args)...);
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#else
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#endif
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
}
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
template <class _Tp, class =
_EnableIf<__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 =
_EnableIf<!__has_destroy<allocator_type, _Tp*>::value> >
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
static void destroy(allocator_type&, _Tp* __p) {
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#if _LIBCPP_STD_VER > 17
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
_VSTD::destroy_at(__p);
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#else
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
__p->~_Tp();
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#endif
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
}
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
template <class _Ap = _Alloc, class =
_EnableIf<__has_max_size<const _Ap>::value> >
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
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 =
_EnableIf<!__has_max_size<const _Ap>::value> >
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
static size_type max_size(const allocator_type&) _NOEXCEPT {
return numeric_limits<size_type>::max() / sizeof(value_type);
}
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
template <class _Ap = _Alloc, class =
_EnableIf<__has_select_on_container_copy_construction<const _Ap>::value> >
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
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 =
_EnableIf<!__has_select_on_container_copy_construction<const _Ap>::value> >
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
static allocator_type select_on_container_copy_construction(const allocator_type& __a) {
return __a;
}
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
};
template <class _Traits, class _Tp>
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
struct __rebind_alloc_helper {
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#ifndef _LIBCPP_CXX03_LANG
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
using type _LIBCPP_NODEBUG_TYPE = typename _Traits::template rebind_alloc<_Tp>;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#else
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
using type = typename _Traits::template rebind_alloc<_Tp>::other;
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
#endif
};
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __is_default_allocator
template <class _Tp>
struct __is_default_allocator : false_type { };
[libcxx][iwyu] ensures we IWYU as prep for modules This has been broken out of D104170 since it should be merged whether or not we go ahead with the module map changes. Differential Revision: https://reviews.llvm.org/D104175
2021-06-12 14:13:44 +08:00
template <class> class allocator;
Revert "[libcxx][module-map] creates submodules for private headers" This reverts commit f1417eb9b1f51b689c78dd8cb0114c1749dd2845 as it uncovered a Clang bug PR50592.
2021-06-08 02:29:03 +08:00
template <class _Tp>
struct __is_default_allocator<allocator<_Tp> > : true_type { };
[libc++] NFCI: Refactor allocator_traits The implementation had a lot of boilerplate and was more complicated than necessary. This NFC refactoring introduces a few macros to reduce code duplication, and uses a consistent style and formatting for the whole file. Differential Revision: https://reviews.llvm.org/D94544
2021-01-13 00:53:24 +08:00
// __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, _EnableIf<
!__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, _EnableIf<
!__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
[libc++] Split allocator_traits and pointer_traits out of <memory> In addition to making the code a lot easier to grasp by localizing many helper functions to the only file where they are actually needed, this will allow creating helper functions that depend on allocator_traits outside of <memory>. This is done as part of implementing array support in allocate_shared, which requires non-trivial array initialization algorithms that would be better to keep out of <memory> for sanity. It's also a first step towards splitting up our monolithic headers into finer grained ones, which will make it easier to reuse functionality across the library. For example, it's just weird that we had to define `addressof` inside <type_traits> to avoid circular dependencies -- instead it's better to implement those in true helper headers. Differential Revision: https://reviews.llvm.org/D93074
2020-12-11 07:28:13 +08:00
_LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS
[libc++] NFC: Normalize `#endif //` comment indentation
2021-04-21 00:03:32 +08:00
#endif // _LIBCPP___MEMORY_ALLOCATOR_TRAITS_H