| // Copyright 2019 The Abseil Authors. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| // ----------------------------------------------------------------------------- |
| // conformance_archetype.h |
| // ----------------------------------------------------------------------------- |
| // |
| // This file contains a facility for generating "archetypes" of out of |
| // "Conformance Profiles" (see "conformance_profiles.h" for more information |
| // about Conformance Profiles). An archetype is a type that aims to support the |
| // bare minimum requirements of a given Conformance Profile. For instance, an |
| // archetype that corresponds to an ImmutableProfile has exactly a nothrow |
| // move-constructor, a potentially-throwing copy constructor, a nothrow |
| // destructor, with all other special-member-functions deleted. These archetypes |
| // are useful for testing to make sure that templates are able to work with the |
| // kinds of types that they claim to support (i.e. that they do not accidentally |
| // under-constrain), |
| // |
| // The main type template in this file is the Archetype template, which takes |
| // a Conformance Profile as a template argument and its instantiations are a |
| // minimum-conforming model of that profile. |
| |
| #ifndef ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_ |
| #define ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_ |
| |
| #include <cstddef> |
| #include <functional> |
| #include <type_traits> |
| #include <utility> |
| |
| #include "absl/meta/type_traits.h" |
| #include "absl/types/internal/conformance_profile.h" |
| |
| namespace absl { |
| ABSL_NAMESPACE_BEGIN |
| namespace types_internal { |
| |
| // A minimum-conforming implementation of a type with properties specified in |
| // `Prof`, where `Prof` is a valid Conformance Profile. |
| template <class Prof, class /*Enabler*/ = void> |
| class Archetype; |
| |
| // Given an Archetype, obtain the properties of the profile associated with that |
| // archetype. |
| template <class Archetype> |
| struct PropertiesOfArchetype; |
| |
| template <class Prof> |
| struct PropertiesOfArchetype<Archetype<Prof>> { |
| using type = PropertiesOfT<Prof>; |
| }; |
| |
| template <class Archetype> |
| using PropertiesOfArchetypeT = typename PropertiesOfArchetype<Archetype>::type; |
| |
| // A metafunction to determine if a type is an `Archetype`. |
| template <class T> |
| struct IsArchetype : std::false_type {}; |
| |
| template <class Prof> |
| struct IsArchetype<Archetype<Prof>> : std::true_type {}; |
| |
| // A constructor tag type used when creating an Archetype with internal state. |
| struct MakeArchetypeState {}; |
| |
| // Data stored within an archetype that is copied/compared/hashed when the |
| // corresponding operations are used. |
| using ArchetypeState = std::size_t; |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // This section of the file defines a chain of base classes for Archetype, // |
| // where each base defines a specific special member function with the // |
| // appropriate properties (deleted, noexcept(false), noexcept, or trivial). // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| // The bottom-most base, which contains the state and the default constructor. |
| template <default_constructible DefaultConstructibleValue> |
| struct ArchetypeStateBase { |
| static_assert(DefaultConstructibleValue == default_constructible::yes || |
| DefaultConstructibleValue == default_constructible::nothrow, |
| ""); |
| |
| ArchetypeStateBase() noexcept( |
| DefaultConstructibleValue == |
| default_constructible:: |
| nothrow) /*Vacuous archetype_state initialization*/ {} |
| explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept |
| : archetype_state(state) {} |
| |
| ArchetypeState archetype_state; |
| }; |
| |
| template <> |
| struct ArchetypeStateBase<default_constructible::maybe> { |
| explicit ArchetypeStateBase() = delete; |
| explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept |
| : archetype_state(state) {} |
| |
| ArchetypeState archetype_state; |
| }; |
| |
| template <> |
| struct ArchetypeStateBase<default_constructible::trivial> { |
| ArchetypeStateBase() = default; |
| explicit ArchetypeStateBase(MakeArchetypeState, ArchetypeState state) noexcept |
| : archetype_state(state) {} |
| |
| ArchetypeState archetype_state; |
| }; |
| |
| // The move-constructor base |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue> |
| struct ArchetypeMoveConstructor |
| : ArchetypeStateBase<DefaultConstructibleValue> { |
| static_assert(MoveConstructibleValue == move_constructible::yes || |
| MoveConstructibleValue == move_constructible::nothrow, |
| ""); |
| |
| explicit ArchetypeMoveConstructor(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(), |
| state) {} |
| |
| ArchetypeMoveConstructor() = default; |
| ArchetypeMoveConstructor(ArchetypeMoveConstructor&& other) noexcept( |
| MoveConstructibleValue == move_constructible::nothrow) |
| : ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(), |
| other.archetype_state) {} |
| ArchetypeMoveConstructor(const ArchetypeMoveConstructor&) = default; |
| ArchetypeMoveConstructor& operator=(ArchetypeMoveConstructor&&) = default; |
| ArchetypeMoveConstructor& operator=(const ArchetypeMoveConstructor&) = |
| default; |
| }; |
| |
| template <default_constructible DefaultConstructibleValue> |
| struct ArchetypeMoveConstructor<DefaultConstructibleValue, |
| move_constructible::trivial> |
| : ArchetypeStateBase<DefaultConstructibleValue> { |
| explicit ArchetypeMoveConstructor(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeStateBase<DefaultConstructibleValue>(MakeArchetypeState(), |
| state) {} |
| |
| ArchetypeMoveConstructor() = default; |
| }; |
| |
| // The copy-constructor base |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue, |
| copy_constructible CopyConstructibleValue> |
| struct ArchetypeCopyConstructor |
| : ArchetypeMoveConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue> { |
| static_assert(CopyConstructibleValue == copy_constructible::yes || |
| CopyConstructibleValue == copy_constructible::nothrow, |
| ""); |
| explicit ArchetypeCopyConstructor(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeMoveConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue>(MakeArchetypeState(), |
| state) {} |
| |
| ArchetypeCopyConstructor() = default; |
| ArchetypeCopyConstructor(ArchetypeCopyConstructor&&) = default; |
| ArchetypeCopyConstructor(const ArchetypeCopyConstructor& other) noexcept( |
| CopyConstructibleValue == copy_constructible::nothrow) |
| : ArchetypeMoveConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue>( |
| MakeArchetypeState(), other.archetype_state) {} |
| ArchetypeCopyConstructor& operator=(ArchetypeCopyConstructor&&) = default; |
| ArchetypeCopyConstructor& operator=(const ArchetypeCopyConstructor&) = |
| default; |
| }; |
| |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue> |
| struct ArchetypeCopyConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue, |
| copy_constructible::maybe> |
| : ArchetypeMoveConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue> { |
| explicit ArchetypeCopyConstructor(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeMoveConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue>(MakeArchetypeState(), |
| state) {} |
| |
| ArchetypeCopyConstructor() = default; |
| ArchetypeCopyConstructor(ArchetypeCopyConstructor&&) = default; |
| ArchetypeCopyConstructor(const ArchetypeCopyConstructor&) = delete; |
| ArchetypeCopyConstructor& operator=(ArchetypeCopyConstructor&&) = default; |
| ArchetypeCopyConstructor& operator=(const ArchetypeCopyConstructor&) = |
| default; |
| }; |
| |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue> |
| struct ArchetypeCopyConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue, |
| copy_constructible::trivial> |
| : ArchetypeMoveConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue> { |
| explicit ArchetypeCopyConstructor(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeMoveConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue>(MakeArchetypeState(), |
| state) {} |
| |
| ArchetypeCopyConstructor() = default; |
| }; |
| |
| // The move-assign base |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue, |
| copy_constructible CopyConstructibleValue, |
| move_assignable MoveAssignableValue> |
| struct ArchetypeMoveAssign |
| : ArchetypeCopyConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue, CopyConstructibleValue> { |
| static_assert(MoveAssignableValue == move_assignable::yes || |
| MoveAssignableValue == move_assignable::nothrow, |
| ""); |
| explicit ArchetypeMoveAssign(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeCopyConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue, |
| CopyConstructibleValue>(MakeArchetypeState(), |
| state) {} |
| |
| ArchetypeMoveAssign() = default; |
| ArchetypeMoveAssign(ArchetypeMoveAssign&&) = default; |
| ArchetypeMoveAssign(const ArchetypeMoveAssign&) = default; |
| ArchetypeMoveAssign& operator=(ArchetypeMoveAssign&& other) noexcept( |
| MoveAssignableValue == move_assignable::nothrow) { |
| this->archetype_state = other.archetype_state; |
| return *this; |
| } |
| |
| ArchetypeMoveAssign& operator=(const ArchetypeMoveAssign&) = default; |
| }; |
| |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue, |
| copy_constructible CopyConstructibleValue> |
| struct ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, move_assignable::trivial> |
| : ArchetypeCopyConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue, CopyConstructibleValue> { |
| explicit ArchetypeMoveAssign(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeCopyConstructor<DefaultConstructibleValue, |
| MoveConstructibleValue, |
| CopyConstructibleValue>(MakeArchetypeState(), |
| state) {} |
| |
| ArchetypeMoveAssign() = default; |
| }; |
| |
| // The copy-assign base |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue, |
| copy_constructible CopyConstructibleValue, |
| move_assignable MoveAssignableValue, |
| copy_assignable CopyAssignableValue> |
| struct ArchetypeCopyAssign |
| : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue> { |
| static_assert(CopyAssignableValue == copy_assignable::yes || |
| CopyAssignableValue == copy_assignable::nothrow, |
| ""); |
| explicit ArchetypeCopyAssign(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue>( |
| MakeArchetypeState(), state) {} |
| |
| ArchetypeCopyAssign() = default; |
| ArchetypeCopyAssign(ArchetypeCopyAssign&&) = default; |
| ArchetypeCopyAssign(const ArchetypeCopyAssign&) = default; |
| ArchetypeCopyAssign& operator=(ArchetypeCopyAssign&&) = default; |
| |
| ArchetypeCopyAssign& operator=(const ArchetypeCopyAssign& other) noexcept( |
| CopyAssignableValue == copy_assignable::nothrow) { |
| this->archetype_state = other.archetype_state; |
| return *this; |
| } |
| }; |
| |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue, |
| copy_constructible CopyConstructibleValue, |
| move_assignable MoveAssignableValue> |
| struct ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue, |
| copy_assignable::maybe> |
| : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue> { |
| explicit ArchetypeCopyAssign(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue>( |
| MakeArchetypeState(), state) {} |
| |
| ArchetypeCopyAssign() = default; |
| ArchetypeCopyAssign(ArchetypeCopyAssign&&) = default; |
| ArchetypeCopyAssign(const ArchetypeCopyAssign&) = default; |
| ArchetypeCopyAssign& operator=(ArchetypeCopyAssign&&) = default; |
| ArchetypeCopyAssign& operator=(const ArchetypeCopyAssign&) = delete; |
| }; |
| |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue, |
| copy_constructible CopyConstructibleValue, |
| move_assignable MoveAssignableValue> |
| struct ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue, |
| copy_assignable::trivial> |
| : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue> { |
| explicit ArchetypeCopyAssign(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeMoveAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue>( |
| MakeArchetypeState(), state) {} |
| |
| ArchetypeCopyAssign() = default; |
| }; |
| |
| // The destructor base |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue, |
| copy_constructible CopyConstructibleValue, |
| move_assignable MoveAssignableValue, |
| copy_assignable CopyAssignableValue, destructible DestructibleValue> |
| struct ArchetypeDestructor |
| : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue, |
| CopyAssignableValue> { |
| static_assert(DestructibleValue == destructible::yes || |
| DestructibleValue == destructible::nothrow, |
| ""); |
| |
| explicit ArchetypeDestructor(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue, |
| CopyAssignableValue>(MakeArchetypeState(), state) {} |
| |
| ArchetypeDestructor() = default; |
| ArchetypeDestructor(ArchetypeDestructor&&) = default; |
| ArchetypeDestructor(const ArchetypeDestructor&) = default; |
| ArchetypeDestructor& operator=(ArchetypeDestructor&&) = default; |
| ArchetypeDestructor& operator=(const ArchetypeDestructor&) = default; |
| ~ArchetypeDestructor() noexcept(DestructibleValue == destructible::nothrow) {} |
| }; |
| |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue, |
| copy_constructible CopyConstructibleValue, |
| move_assignable MoveAssignableValue, |
| copy_assignable CopyAssignableValue> |
| struct ArchetypeDestructor<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue, |
| CopyAssignableValue, destructible::trivial> |
| : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue, |
| CopyAssignableValue> { |
| explicit ArchetypeDestructor(MakeArchetypeState, |
| ArchetypeState state) noexcept |
| : ArchetypeCopyAssign<DefaultConstructibleValue, MoveConstructibleValue, |
| CopyConstructibleValue, MoveAssignableValue, |
| CopyAssignableValue>(MakeArchetypeState(), state) {} |
| |
| ArchetypeDestructor() = default; |
| }; |
| |
| // An alias to the top of the chain of bases for special-member functions. |
| // NOTE: move_constructible::maybe, move_assignable::maybe, and |
| // destructible::maybe are handled in the top-level type by way of SFINAE. |
| // Because of this, we never instantiate the base classes with |
| // move_constructible::maybe, move_assignable::maybe, or destructible::maybe so |
| // that we minimize the number of different possible type-template |
| // instantiations. |
| template <default_constructible DefaultConstructibleValue, |
| move_constructible MoveConstructibleValue, |
| copy_constructible CopyConstructibleValue, |
| move_assignable MoveAssignableValue, |
| copy_assignable CopyAssignableValue, destructible DestructibleValue> |
| using ArchetypeSpecialMembersBase = ArchetypeDestructor< |
| DefaultConstructibleValue, |
| MoveConstructibleValue != move_constructible::maybe |
| ? MoveConstructibleValue |
| : move_constructible::nothrow, |
| CopyConstructibleValue, |
| MoveAssignableValue != move_assignable::maybe ? MoveAssignableValue |
| : move_assignable::nothrow, |
| CopyAssignableValue, |
| DestructibleValue != destructible::maybe ? DestructibleValue |
| : destructible::nothrow>; |
| |
| // A function that is used to create an archetype with some associated state. |
| template <class Arch> |
| Arch MakeArchetype(ArchetypeState state) noexcept { |
| static_assert(IsArchetype<Arch>::value, |
| "The explicit template argument to MakeArchetype is required " |
| "to be an Archetype."); |
| return Arch(MakeArchetypeState(), state); |
| } |
| |
| // This is used to conditionally delete "copy" and "move" constructors in a way |
| // that is consistent with what the ConformanceProfile requires and that also |
| // strictly enforces the arguments to the copy/move to not come from implicit |
| // conversions when dealing with the Archetype. |
| template <class Prof, class T> |
| constexpr bool ShouldDeleteConstructor() { |
| return !((PropertiesOfT<Prof>::move_constructible_support != |
| move_constructible::maybe && |
| std::is_same<T, Archetype<Prof>>::value) || |
| (PropertiesOfT<Prof>::copy_constructible_support != |
| copy_constructible::maybe && |
| (std::is_same<T, const Archetype<Prof>&>::value || |
| std::is_same<T, Archetype<Prof>&>::value || |
| std::is_same<T, const Archetype<Prof>>::value))); |
| } |
| |
| // This is used to conditionally delete "copy" and "move" assigns in a way |
| // that is consistent with what the ConformanceProfile requires and that also |
| // strictly enforces the arguments to the copy/move to not come from implicit |
| // conversions when dealing with the Archetype. |
| template <class Prof, class T> |
| constexpr bool ShouldDeleteAssign() { |
| return !( |
| (PropertiesOfT<Prof>::move_assignable_support != move_assignable::maybe && |
| std::is_same<T, Archetype<Prof>>::value) || |
| (PropertiesOfT<Prof>::copy_assignable_support != copy_assignable::maybe && |
| (std::is_same<T, const Archetype<Prof>&>::value || |
| std::is_same<T, Archetype<Prof>&>::value || |
| std::is_same<T, const Archetype<Prof>>::value))); |
| } |
| |
| // TODO(calabrese) Inherit from a chain of secondary bases to pull in the |
| // associated functions of other concepts. |
| template <class Prof, class Enabler> |
| class Archetype : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support> { |
| static_assert(std::is_same<Enabler, void>::value, |
| "An explicit type must not be passed as the second template " |
| "argument to 'Archetype`."); |
| |
| // The cases mentioned in these static_asserts are expected to be handled in |
| // the partial template specializations of Archetype that follow this |
| // definition. |
| static_assert(PropertiesOfT<Prof>::destructible_support != |
| destructible::maybe, |
| ""); |
| static_assert(PropertiesOfT<Prof>::move_constructible_support != |
| move_constructible::maybe || |
| PropertiesOfT<Prof>::copy_constructible_support == |
| copy_constructible::maybe, |
| ""); |
| static_assert(PropertiesOfT<Prof>::move_assignable_support != |
| move_assignable::maybe || |
| PropertiesOfT<Prof>::copy_assignable_support == |
| copy_assignable::maybe, |
| ""); |
| |
| public: |
| Archetype() = default; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteConstructor<Prof, T>()>::type* = nullptr> |
| Archetype(T&&) = delete; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteAssign<Prof, T>()>::type* = nullptr> |
| Archetype& operator=(T&&) = delete; |
| |
| using ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>::archetype_state; |
| |
| private: |
| explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), |
| state) {} |
| |
| friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept; |
| }; |
| |
| template <class Prof> |
| class Archetype<Prof, typename std::enable_if< |
| PropertiesOfT<Prof>::move_constructible_support != |
| move_constructible::maybe && |
| PropertiesOfT<Prof>::move_assignable_support == |
| move_assignable::maybe && |
| PropertiesOfT<Prof>::destructible_support != |
| destructible::maybe>::type> |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support> { |
| public: |
| Archetype() = default; |
| Archetype(Archetype&&) = default; |
| Archetype(const Archetype&) = default; |
| Archetype& operator=(Archetype&&) = delete; |
| Archetype& operator=(const Archetype&) = default; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteConstructor<Prof, T>()>::type* = nullptr> |
| Archetype(T&&) = delete; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteAssign<Prof, T>()>::type* = nullptr> |
| Archetype& operator=(T&&) = delete; |
| |
| using ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>::archetype_state; |
| |
| private: |
| explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), |
| state) {} |
| |
| friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept; |
| }; |
| |
| template <class Prof> |
| class Archetype<Prof, typename std::enable_if< |
| PropertiesOfT<Prof>::move_constructible_support == |
| move_constructible::maybe && |
| PropertiesOfT<Prof>::move_assignable_support == |
| move_assignable::maybe && |
| PropertiesOfT<Prof>::destructible_support != |
| destructible::maybe>::type> |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support> { |
| public: |
| Archetype() = default; |
| Archetype(Archetype&&) = delete; |
| Archetype(const Archetype&) = default; |
| Archetype& operator=(Archetype&&) = delete; |
| Archetype& operator=(const Archetype&) = default; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteConstructor<Prof, T>()>::type* = nullptr> |
| Archetype(T&&) = delete; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteAssign<Prof, T>()>::type* = nullptr> |
| Archetype& operator=(T&&) = delete; |
| |
| using ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>::archetype_state; |
| |
| private: |
| explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), |
| state) {} |
| |
| friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept; |
| }; |
| |
| template <class Prof> |
| class Archetype<Prof, typename std::enable_if< |
| PropertiesOfT<Prof>::move_constructible_support == |
| move_constructible::maybe && |
| PropertiesOfT<Prof>::move_assignable_support != |
| move_assignable::maybe && |
| PropertiesOfT<Prof>::destructible_support != |
| destructible::maybe>::type> |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support> { |
| public: |
| Archetype() = default; |
| Archetype(Archetype&&) = delete; |
| Archetype(const Archetype&) = default; |
| Archetype& operator=(Archetype&&) = default; |
| Archetype& operator=(const Archetype&) = default; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteConstructor<Prof, T>()>::type* = nullptr> |
| Archetype(T&&) = delete; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteAssign<Prof, T>()>::type* = nullptr> |
| Archetype& operator=(T&&) = delete; |
| |
| using ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>::archetype_state; |
| |
| private: |
| explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), |
| state) {} |
| |
| friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept; |
| }; |
| |
| template <class Prof> |
| class Archetype<Prof, typename std::enable_if< |
| PropertiesOfT<Prof>::move_constructible_support != |
| move_constructible::maybe && |
| PropertiesOfT<Prof>::move_assignable_support == |
| move_assignable::maybe && |
| PropertiesOfT<Prof>::destructible_support == |
| destructible::maybe>::type> |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support> { |
| public: |
| Archetype() = default; |
| Archetype(Archetype&&) = default; |
| Archetype(const Archetype&) = default; |
| Archetype& operator=(Archetype&&) = delete; |
| Archetype& operator=(const Archetype&) = default; |
| ~Archetype() = delete; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteConstructor<Prof, T>()>::type* = nullptr> |
| Archetype(T&&) = delete; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteAssign<Prof, T>()>::type* = nullptr> |
| Archetype& operator=(T&&) = delete; |
| |
| using ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>::archetype_state; |
| |
| private: |
| explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), |
| state) {} |
| |
| friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept; |
| }; |
| |
| template <class Prof> |
| class Archetype<Prof, typename std::enable_if< |
| PropertiesOfT<Prof>::move_constructible_support == |
| move_constructible::maybe && |
| PropertiesOfT<Prof>::move_assignable_support == |
| move_assignable::maybe && |
| PropertiesOfT<Prof>::destructible_support == |
| destructible::maybe>::type> |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support> { |
| public: |
| Archetype() = default; |
| Archetype(Archetype&&) = delete; |
| Archetype(const Archetype&) = default; |
| Archetype& operator=(Archetype&&) = delete; |
| Archetype& operator=(const Archetype&) = default; |
| ~Archetype() = delete; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteConstructor<Prof, T>()>::type* = nullptr> |
| Archetype(T&&) = delete; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteAssign<Prof, T>()>::type* = nullptr> |
| Archetype& operator=(T&&) = delete; |
| |
| using ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>::archetype_state; |
| |
| private: |
| explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), |
| state) {} |
| |
| friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept; |
| }; |
| |
| template <class Prof> |
| class Archetype<Prof, typename std::enable_if< |
| PropertiesOfT<Prof>::move_constructible_support == |
| move_constructible::maybe && |
| PropertiesOfT<Prof>::move_assignable_support != |
| move_assignable::maybe && |
| PropertiesOfT<Prof>::destructible_support == |
| destructible::maybe>::type> |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support> { |
| public: |
| Archetype() = default; |
| Archetype(Archetype&&) = delete; |
| Archetype(const Archetype&) = default; |
| Archetype& operator=(Archetype&&) = default; |
| Archetype& operator=(const Archetype&) = default; |
| ~Archetype() = delete; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteConstructor<Prof, T>()>::type* = nullptr> |
| Archetype(T&&) = delete; |
| |
| // Disallow moves when requested, and disallow implicit conversions. |
| template <class T, typename std::enable_if< |
| ShouldDeleteAssign<Prof, T>()>::type* = nullptr> |
| Archetype& operator=(T&&) = delete; |
| |
| using ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>::archetype_state; |
| |
| private: |
| explicit Archetype(MakeArchetypeState, ArchetypeState state) noexcept |
| : ArchetypeSpecialMembersBase< |
| PropertiesOfT<Prof>::default_constructible_support, |
| PropertiesOfT<Prof>::move_constructible_support, |
| PropertiesOfT<Prof>::copy_constructible_support, |
| PropertiesOfT<Prof>::move_assignable_support, |
| PropertiesOfT<Prof>::copy_assignable_support, |
| PropertiesOfT<Prof>::destructible_support>(MakeArchetypeState(), |
| state) {} |
| |
| friend Archetype MakeArchetype<Archetype>(ArchetypeState) noexcept; |
| }; |
| |
| // Explicitly deleted swap for Archetype if the profile does not require swap. |
| // It is important to delete it rather than simply leave it out so that the |
| // "using std::swap;" idiom will result in this deleted overload being picked. |
| template <class Prof, |
| absl::enable_if_t<!PropertiesOfT<Prof>::is_swappable, int> = 0> |
| void swap(Archetype<Prof>&, Archetype<Prof>&) = delete; // NOLINT |
| |
| // A conditionally-noexcept swap implementation for Archetype when the profile |
| // supports swap. |
| template <class Prof, |
| absl::enable_if_t<PropertiesOfT<Prof>::is_swappable, int> = 0> |
| void swap(Archetype<Prof>& lhs, Archetype<Prof>& rhs) // NOLINT |
| noexcept(PropertiesOfT<Prof>::swappable_support != swappable::yes) { |
| std::swap(lhs.archetype_state, rhs.archetype_state); |
| } |
| |
| // A convertible-to-bool type that is used as the return type of comparison |
| // operators since the standard doesn't always require exactly bool. |
| struct NothrowBool { |
| explicit NothrowBool() = delete; |
| ~NothrowBool() = default; |
| |
| // TODO(calabrese) Delete the copy constructor in C++17 mode since guaranteed |
| // elision makes it not required when returning from a function. |
| // NothrowBool(NothrowBool const&) = delete; |
| |
| NothrowBool& operator=(NothrowBool const&) = delete; |
| |
| explicit operator bool() const noexcept { return value; } |
| |
| static NothrowBool make(bool const value) noexcept { |
| return NothrowBool(value); |
| } |
| |
| private: |
| explicit NothrowBool(bool const value) noexcept : value(value) {} |
| |
| bool value; |
| }; |
| |
| // A convertible-to-bool type that is used as the return type of comparison |
| // operators since the standard doesn't always require exactly bool. |
| // Note: ExceptionalBool has a conversion operator that is not noexcept, so |
| // that even when a comparison operator is noexcept, that operation may still |
| // potentially throw when converted to bool. |
| struct ExceptionalBool { |
| explicit ExceptionalBool() = delete; |
| ~ExceptionalBool() = default; |
| |
| // TODO(calabrese) Delete the copy constructor in C++17 mode since guaranteed |
| // elision makes it not required when returning from a function. |
| // ExceptionalBool(ExceptionalBool const&) = delete; |
| |
| ExceptionalBool& operator=(ExceptionalBool const&) = delete; |
| |
| explicit operator bool() const { return value; } // NOLINT |
| |
| static ExceptionalBool make(bool const value) noexcept { |
| return ExceptionalBool(value); |
| } |
| |
| private: |
| explicit ExceptionalBool(bool const value) noexcept : value(value) {} |
| |
| bool value; |
| }; |
| |
| // The following macro is only used as a helper in this file to stamp out |
| // comparison operator definitions. It is undefined after usage. |
| // |
| // NOTE: Non-nothrow operators throw via their result's conversion to bool even |
| // though the operation itself is noexcept. |
| #define ABSL_TYPES_INTERNAL_OP(enum_name, op) \ |
| template <class Prof> \ |
| absl::enable_if_t<!PropertiesOfT<Prof>::is_##enum_name, bool> operator op( \ |
| const Archetype<Prof>&, const Archetype<Prof>&) = delete; \ |
| \ |
| template <class Prof> \ |
| typename absl::enable_if_t< \ |
| PropertiesOfT<Prof>::is_##enum_name, \ |
| std::conditional<PropertiesOfT<Prof>::enum_name##_support == \ |
| enum_name::nothrow, \ |
| NothrowBool, ExceptionalBool>>::type \ |
| operator op(const Archetype<Prof>& lhs, \ |
| const Archetype<Prof>& rhs) noexcept { \ |
| return absl::conditional_t< \ |
| PropertiesOfT<Prof>::enum_name##_support == enum_name::nothrow, \ |
| NothrowBool, ExceptionalBool>::make(lhs.archetype_state op \ |
| rhs.archetype_state); \ |
| } |
| |
| ABSL_TYPES_INTERNAL_OP(equality_comparable, ==); |
| ABSL_TYPES_INTERNAL_OP(inequality_comparable, !=); |
| ABSL_TYPES_INTERNAL_OP(less_than_comparable, <); |
| ABSL_TYPES_INTERNAL_OP(less_equal_comparable, <=); |
| ABSL_TYPES_INTERNAL_OP(greater_equal_comparable, >=); |
| ABSL_TYPES_INTERNAL_OP(greater_than_comparable, >); |
| |
| #undef ABSL_TYPES_INTERNAL_OP |
| |
| // Base class for std::hash specializations when an Archetype doesn't support |
| // hashing. |
| struct PoisonedHash { |
| PoisonedHash() = delete; |
| PoisonedHash(const PoisonedHash&) = delete; |
| PoisonedHash& operator=(const PoisonedHash&) = delete; |
| }; |
| |
| // Base class for std::hash specializations when an Archetype supports hashing. |
| template <class Prof> |
| struct EnabledHash { |
| using argument_type = Archetype<Prof>; |
| using result_type = std::size_t; |
| result_type operator()(const argument_type& arg) const { |
| return std::hash<ArchetypeState>()(arg.archetype_state); |
| } |
| }; |
| |
| } // namespace types_internal |
| ABSL_NAMESPACE_END |
| } // namespace absl |
| |
| namespace std { |
| |
| template <class Prof> // NOLINT |
| struct hash<::absl::types_internal::Archetype<Prof>> |
| : conditional<::absl::types_internal::PropertiesOfT<Prof>::is_hashable, |
| ::absl::types_internal::EnabledHash<Prof>, |
| ::absl::types_internal::PoisonedHash>::type {}; |
| |
| } // namespace std |
| |
| #endif // ABSL_TYPES_INTERNAL_CONFORMANCE_ARCHETYPE_H_ |
