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.

414 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 {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = typename _RawAlloc::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
};
template <class _Tp, class _Alloc, class _RawAlloc>
struct __pointer<_Tp, _Alloc, _RawAlloc, false> {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = _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
};
// __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 {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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 {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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 {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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> {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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 {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::difference_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
};
template <class _Alloc, class _Ptr>
struct __alloc_traits_difference_type<_Alloc, _Ptr, true> {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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> {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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> {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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> {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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> {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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 {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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> {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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> {
[libc++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = _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 =
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
__enable_if_t<__has_allocate_hint<_Ap, size_type, const_void_pointer>::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
_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 =
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
__enable_if_t<!__has_allocate_hint<_Ap, size_type, const_void_pointer>::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
_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 =
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
__enable_if_t<__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 =
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
__enable_if_t<!__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 =
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
__enable_if_t<__has_destroy<allocator_type, _Tp*>::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
_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 =
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
__enable_if_t<!__has_destroy<allocator_type, _Tp*>::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
_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 =
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
__enable_if_t<__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 =
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
__enable_if_t<!__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 =
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
__enable_if_t<__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 =
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
__enable_if_t<!__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
};
[libc++] P0433R2: test that deduction guides are properly SFINAEd away. Deduction guides for containers should not participate in overload resolution when called with certain incorrect types (e.g. when called with a template argument in place of an `InputIterator` that doesn't qualify as an input iterator). Similarly, class template argument deduction should not select `unique_ptr` constructors that take a a pointer. The tests try out every possible incorrect parameter (but never more than one incorrect parameter in the same invocation). Also add deduction guides to the synopsis for associative and unordered containers (this was accidentally omitted from [D112510](https://reviews.llvm.org/D112510)). Differential Revision: https://reviews.llvm.org/D112904
2021-11-10 01:21:02 +08:00
// A version of `allocator_traits` for internal usage that SFINAEs away if the
// given allocator doesn't have a nested `value_type`. This helps avoid hard
// errors when forming implicit deduction guides for a container that has an
// invalid Allocator type. See https://wg21.link/LWGXXXXX.
// TODO(varconst): use the actual link once available.
template <class _Alloc, class _ValueType = typename _Alloc::value_type>
struct _LIBCPP_TEMPLATE_VIS __allocator_traits : allocator_traits<_Alloc> {};
[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++] Remove workarounds for [[nodebug]] not working properly on typedefs in older Clangs Clang used to support [[nodebug]] everywhere except on typedefs. Since we don't support such old Clangs anymore, we can get rid of _LIBCPP_NODEBUG_TYPE in favour of always using _LIBCPP_NODEBUG. Differential Revision: https://reviews.llvm.org/D108996
2021-08-31 22:32:11 +08:00
using type _LIBCPP_NODEBUG = 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>
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
struct __is_cpp17_move_insertable<_Alloc, __enable_if_t<
[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<_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>
[libc++][NFC] Rename _EnableIf to __enable_if_t for consistency In other places in the code, we use lowercase spelling for things that are not available in prior standards. Differential Revision: https://reviews.llvm.org/D109435
2021-09-08 21:14:43 +08:00
struct __is_cpp17_copy_insertable<_Alloc, __enable_if_t<
[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<_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