From 5ebb8b0fa8d70aa05af926cdbdb15c9b92e26a96 Mon Sep 17 00:00:00 2001 From: Jamie Reece Wilson Date: Mon, 11 Mar 2024 18:05:34 +0000 Subject: [PATCH] [*] Further reduced std references --- .../ThirdParty/tartanllamaOptional.hpp | 221 +++++++++--------- Include/auROXTL/auTemplateMeta.hpp | 197 +++++++++++++++- 2 files changed, 305 insertions(+), 113 deletions(-) diff --git a/Include/auROXTL/ThirdParty/tartanllamaOptional.hpp b/Include/auROXTL/ThirdParty/tartanllamaOptional.hpp index 0f6a7e3..d5c8cc7 100644 --- a/Include/auROXTL/ThirdParty/tartanllamaOptional.hpp +++ b/Include/auROXTL/ThirdParty/tartanllamaOptional.hpp @@ -57,7 +57,7 @@ #define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign::value // This one will be different for GCC 5.7 if it's ever supported -#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible::value +#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) AuIsTriviallyDestructible::value // GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks std::vector // for non-copyable types @@ -84,13 +84,13 @@ namespace tl { tl::detail::is_trivially_copy_constructible::value #define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ std::is_trivially_copy_assignable::value -#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible::value +#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) AuIsTriviallyDestructible::value #else #define TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \ - std::is_trivially_copy_constructible::value + AuIsTriviallyCopyConstructible::value #define TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \ - std::is_trivially_copy_assignable::value -#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible::value + AuIsTriviallyCopyAssignable::value +#define TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) AuIsTriviallyDestructible::value #endif #if __cplusplus > 201103L @@ -127,10 +127,10 @@ namespace tl { #ifndef TL_TRAITS_MUTEX #define TL_TRAITS_MUTEX // C++14-style aliases for brevity - template using remove_const_t = typename std::remove_const::type; + template using remove_const_t = typename AuRemoveConst::type; template - using remove_reference_t = typename std::remove_reference::type; - template using decay_t = typename std::decay::type; + using remove_reference_t = typename AuRemoveReference::type; + template using decay_t = typename AuDecay::type; template using enable_if_t = typename AuEnableIf::type; template @@ -241,7 +241,7 @@ namespace tl { { }; template tag swap(T &, T &); - template tag swap(T(&a)[N], T(&b)[N]); + template tag swap(T(&a)[N], T(&b)[N]); // helper functions to test if an unqualified swap is possible, and if it // becomes std::swap @@ -253,40 +253,38 @@ namespace tl { template AuFalseType uses_std(...); template - std::is_same(), AuDecalVal())), tag> + AuIsSame(), AuDecalVal())), tag> uses_std(int); template struct is_std_swap_noexcept - : std::integral_constant::value && - std::is_nothrow_move_assignable::value> + : AuBoolType< + AuIsNothrowMoveConstructible::value && + AuIsNothrowMoveAssignable::value> { }; - template + template struct is_std_swap_noexcept : is_std_swap_noexcept { }; template struct is_adl_swap_noexcept - : std::integral_constant(0))> + : AuBoolType(0))> { }; } // namespace swap_adl_tests template struct is_swappable - : std::integral_constant< - bool, + : AuBoolType< decltype(detail::swap_adl_tests::can_swap(0))::value && (!decltype(detail::swap_adl_tests::uses_std(0))::value || - (std::is_move_assignable::value && - std::is_move_constructible::value))> + (AuIsMoveAssignable::value && + AuIsMoveConstructible::value))> { }; - template + template struct is_swappable - : std::integral_constant< - bool, + : AuBoolType< decltype(detail::swap_adl_tests::can_swap(0))::value && (!decltype( detail::swap_adl_tests::uses_std(0))::value || @@ -295,8 +293,7 @@ namespace tl { template struct is_nothrow_swappable - : std::integral_constant< - bool, + : AuBoolType< is_swappable::value && ((decltype(detail::swap_adl_tests::uses_std(0))::value &&detail::swap_adl_tests::is_std_swap_noexcept::value) || @@ -323,7 +320,7 @@ namespace tl { // Change void to tl::monostate template - using fixup_void = conditional_t::value, monostate, U>; + using fixup_void = conditional_t::value, monostate, U>; template > using get_map_return = optional>>; @@ -332,7 +329,7 @@ namespace tl { template struct returns_void_impl; template struct returns_void_impl>, U...> - : std::is_void> + : AuIsVoid> { }; template using returns_void = AuIsVoid>; // returns_void_impl; @@ -345,50 +342,50 @@ namespace tl { template using enable_forward_value = - detail::enable_if_t::value && - !std::is_same, in_place_t>::value && - !std::is_same, detail::decay_t>::value>; + detail::enable_if_t::value && + !AuIsSame, in_place_t>::value && + !AuIsSame, detail::decay_t>::value>; template using enable_from_other = detail::enable_if_t< - std::is_constructible::value && - !std::is_constructible &>::value && - !std::is_constructible &&>::value && - !std::is_constructible &>::value && - !std::is_constructible &&>::value && - !std::is_convertible &, T>::value && - !std::is_convertible &&, T>::value && - !std::is_convertible &, T>::value && - !std::is_convertible &&, T>::value>; + AuIsConstructible::value && + !AuIsConstructible &>::value && + !AuIsConstructible &&>::value && + !AuIsConstructible &>::value && + !AuIsConstructible &&>::value && + !AuIsConvertible &, T>::value && + !AuIsConvertible &&, T>::value && + !AuIsConvertible &, T>::value && + !AuIsConvertible &&, T>::value>; template using enable_assign_forward = detail::enable_if_t< - !std::is_same, detail::decay_t>::value && + !AuIsSame, detail::decay_t>::value && !detail::conjunction, - std::is_same>>::value && - std::is_constructible::value &&std::is_assignable::value>; + AuIsSame>>::value && + AuIsConstructible::value &&AuIsAssignable::value>; template using enable_assign_from_other = detail::enable_if_t< - std::is_constructible::value && - std::is_assignable::value && - !std::is_constructible &>::value && - !std::is_constructible &&>::value && - !std::is_constructible &>::value && - !std::is_constructible &&>::value && - !std::is_convertible &, T>::value && - !std::is_convertible &&, T>::value && - !std::is_convertible &, T>::value && - !std::is_convertible &&, T>::value && - !std::is_assignable &>::value && - !std::is_assignable &&>::value && - !std::is_assignable &>::value && - !std::is_assignable &&>::value>; + AuIsConstructible::value && + AuIsAssignable::value && + !AuIsConstructible &>::value && + !AuIsConstructible &&>::value && + !AuIsConstructible &>::value && + !AuIsConstructible &&>::value && + !AuIsConvertible &, T>::value && + !AuIsConvertible &&, T>::value && + !AuIsConvertible &, T>::value && + !AuIsConvertible &&, T>::value && + !AuIsAssignable &>::value && + !AuIsAssignable &&>::value && + !AuIsAssignable &>::value && + !AuIsAssignable &&>::value>; // The storage base manages the actual storage, and correctly propagates // trivial destruction from T. This case is for when T is not trivially // destructible. - template ::value> + template ::value> struct optional_storage_base { TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept @@ -548,7 +545,7 @@ namespace tl { // have to make do with a non-trivial move constructor even if T is trivially // move constructible #ifndef TL_OPTIONAL_GCC49 - template ::value> + template ::value> struct optional_move_base : optional_copy_base { using optional_copy_base::optional_copy_base; @@ -564,7 +561,7 @@ namespace tl { optional_move_base(const optional_move_base &rhs) = default; optional_move_base(optional_move_base &&rhs) noexcept( - std::is_nothrow_move_constructible::value) + AuIsNothrowMoveConstructible::value) { if (rhs.has_value()) { @@ -608,13 +605,13 @@ namespace tl { // This class manages conditionally having a trivial move assignment operator // Unfortunately there's no way to achieve this in GCC < 5 AFAIK, since it - // doesn't implement an analogue to std::is_trivially_move_assignable. We have + // doesn't implement an analogue to AuIsTriviallyAssignable. We have // to make do with a non-trivial move assignment operator even if T is trivially // move assignable #ifndef TL_OPTIONAL_GCC49 - template ::value - &&std::is_trivially_move_constructible::value - &&std::is_trivially_move_assignable::value> + template ::value + &&AuIsTriviallyMoveConstructible::value + &&AuIsTriviallyMoveAssignable::value> struct optional_move_assign_base : optional_copy_assign_base { using optional_copy_assign_base::optional_copy_assign_base; @@ -638,8 +635,8 @@ namespace tl { optional_move_assign_base & operator=(optional_move_assign_base &&rhs) noexcept( - std::is_nothrow_move_constructible::value - &&std::is_nothrow_move_assignable::value) + AuIsNothrowMoveConstructible::value + &&AuIsNothrowMoveAssignable::value) { this->assign(AuMove(rhs)); return *this; @@ -648,8 +645,8 @@ namespace tl { // optional_delete_ctor_base will conditionally delete copy and move // constructors depending on whether T is copy/move constructible - template ::value, - bool EnableMove = std::is_move_constructible::value> + template ::value, + bool EnableMove = AuIsMoveConstructible::value> struct optional_delete_ctor_base { optional_delete_ctor_base() = default; @@ -697,10 +694,10 @@ namespace tl { // optional_delete_assign_base will conditionally delete copy and move // constructors depending on whether T is copy/move constructible + assignable template ::value && - std::is_copy_assignable::value), - bool EnableMove = (std::is_move_constructible::value && - std::is_move_assignable::value)> + bool EnableCopy = (AuIsCopyConstructible::value && + AuIsCopyAssignable::value), + bool EnableMove = (AuIsMoveConstructible::value && + AuIsMoveAssignable::value)> struct optional_delete_assign_base { optional_delete_assign_base() = default; @@ -786,9 +783,9 @@ namespace tl { { using base = detail::optional_move_assign_base; - static_assert(!std::is_same::value, + static_assert(!AuIsSame::value, "instantiation of optional with in_place_t is ill-formed"); - static_assert(!std::is_same, nullopt_t>::value, + static_assert(!AuIsSame, nullopt_t>::value, "instantiation of optional with nullopt_t is ill-formed"); public: @@ -1457,14 +1454,14 @@ namespace tl { /// Returns `u` if `*this` has a value, otherwise an empty optional. template - constexpr optional::type> conjunction(U &&u) const + constexpr optional::type> conjunction(U &&u) const { using result = optional>; return has_value() ? result{u} : result { nullopt }; } template - constexpr optional::type> Conjunction(U &&u) const + constexpr optional::type> Conjunction(U &&u) const { using result = optional>; return has_value() ? result{u} : result { nullopt }; @@ -1599,14 +1596,14 @@ namespace tl { /// Constructs the stored value in-place using the given arguments. template constexpr explicit optional( - detail::enable_if_t::value, in_place_t>, + detail::enable_if_t::value, in_place_t>, Args &&... args) : base(in_place, AuForward(args)...) { } template TL_OPTIONAL_11_CONSTEXPR explicit optional( - detail::enable_if_t &, + detail::enable_if_t &, Args &&...>::value, in_place_t>, std::initializer_list il, Args &&... args) @@ -1617,14 +1614,14 @@ namespace tl { /// Constructs the stored value with `u`. template < class U = T, - detail::enable_if_t::value> * = nullptr, + detail::enable_if_t::value> * = nullptr, detail::enable_forward_value * = nullptr> constexpr optional(U &&u) : base(in_place, AuForward(u)) { } template < class U = T, - detail::enable_if_t::value> * = nullptr, + detail::enable_if_t::value> * = nullptr, detail::enable_forward_value * = nullptr> constexpr explicit optional(U &&u) : base(in_place, AuForward(u)) { } @@ -1632,7 +1629,7 @@ namespace tl { /// Converting copy constructor. template < class U, detail::enable_from_other * = nullptr, - detail::enable_if_t::value> * = nullptr> + detail::enable_if_t::value> * = nullptr> optional(const optional &rhs) { if (rhs.has_value()) @@ -1642,7 +1639,7 @@ namespace tl { } template * = nullptr, - detail::enable_if_t::value> * = + detail::enable_if_t::value> * = nullptr> explicit optional(const optional &rhs) { @@ -1655,7 +1652,7 @@ namespace tl { /// Converting move constructor. template < class U, detail::enable_from_other * = nullptr, - detail::enable_if_t::value> * = nullptr> + detail::enable_if_t::value> * = nullptr> optional(optional &&rhs) { if (rhs.has_value()) @@ -1666,7 +1663,7 @@ namespace tl { template < class U, detail::enable_from_other * = nullptr, - detail::enable_if_t::value> * = nullptr> + detail::enable_if_t::value> * = nullptr> explicit optional(optional &&rhs) { if (rhs.has_value()) @@ -1781,7 +1778,7 @@ namespace tl { /// one. template T &emplace(Args &&... args) { - static_assert(std::is_constructible::value, + static_assert(AuIsConstructible::value, "T must be constructible with Args"); *this = nullopt; @@ -1791,7 +1788,7 @@ namespace tl { template detail::enable_if_t< - std::is_constructible &, Args &&...>::value, + AuIsConstructible &, Args &&...>::value, T &> emplace(std::initializer_list il, Args &&... args) { @@ -1806,7 +1803,7 @@ namespace tl { /// If both have a value, the values are swapped. /// If one has a value, it is moved to the other and the movee is left /// valueless. - void swap(optional &rhs) noexcept(std::is_nothrow_move_constructible::value + void swap(optional &rhs) noexcept(AuIsNothrowMoveConstructible::value &&detail::is_nothrow_swappable::value) { using std::swap; @@ -1830,7 +1827,7 @@ namespace tl { swap(this->m_has_value, rhs.m_has_value); } - void Swap(optional &rhs) noexcept(std::is_nothrow_move_constructible::value + void Swap(optional &rhs) noexcept(AuIsNothrowMoveConstructible::value &&detail::is_nothrow_swappable::value) { using std::swap; @@ -1964,16 +1961,16 @@ namespace tl { /// Returns the stored value if there is one, otherwise returns `u` template constexpr T value_or(U &&u) const & { - static_assert(std::is_copy_constructible::value && - std::is_convertible::value, + static_assert(AuIsCopyConstructible::value && + AuIsConvertible::value, "T must be copy constructible and convertible from U"); return has_value() ? **this : static_cast(AuForward(u)); } template TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && { - static_assert(std::is_move_constructible::value && - std::is_convertible::value, + static_assert(AuIsMoveConstructible::value && + AuIsConvertible::value, "T must be move constructible and convertible from U"); return has_value() ? AuMove(**this) : static_cast(AuForward(u)); } @@ -1981,16 +1978,16 @@ namespace tl { /// Returns the stored value if there is one, otherwise returns `u` template constexpr T ValueOr(U &&u) const & { - static_assert(std::is_copy_constructible::value && - std::is_convertible::value, + static_assert(AuIsCopyConstructible::value && + AuIsConvertible::value, "T must be copy constructible and convertible from U"); return has_value() ? **this : static_cast(AuForward(u)); } template TL_OPTIONAL_11_CONSTEXPR T ValueOr(U &&u) && { - static_assert(std::is_move_constructible::value && - std::is_convertible::value, + static_assert(AuIsMoveConstructible::value && + AuIsConvertible::value, "T must be move constructible and convertible from U"); return has_value() ? AuMove(**this) : static_cast(AuForward(u)); } @@ -2186,7 +2183,7 @@ namespace tl { } template ::value> * = nullptr, + detail::enable_if_t::value> * = nullptr, detail::enable_if_t::value> * = nullptr> void swap(optional &lhs, optional &rhs) noexcept(noexcept(lhs.swap(rhs))) @@ -2201,7 +2198,7 @@ namespace tl { template ::value, + detail::conditional_t::value, detail::decay_t, T>> inline constexpr optional make_optional(U &&v) { @@ -2230,7 +2227,7 @@ namespace tl { template (), *AuDecalVal())), - detail::enable_if_t::value> * = nullptr> + detail::enable_if_t::value> * = nullptr> constexpr auto optional_map_impl(Opt &&opt, F &&f) { return opt.has_value() @@ -2241,7 +2238,7 @@ namespace tl { template (), *AuDecalVal())), - detail::enable_if_t::value> * = nullptr> + detail::enable_if_t::value> * = nullptr> auto optional_map_impl(Opt &&opt, F &&f) { if (opt.has_value()) @@ -2256,7 +2253,7 @@ namespace tl { template (), *AuDecalVal())), - detail::enable_if_t::value> * = nullptr> + detail::enable_if_t::value> * = nullptr> constexpr auto optional_map_impl(Opt &&opt, F &&f) -> optional { @@ -2268,7 +2265,7 @@ namespace tl { template (), *AuDecalVal())), - detail::enable_if_t::value> * = nullptr> + detail::enable_if_t::value> * = nullptr> auto optional_map_impl(Opt &&opt, F &&f) -> optional { @@ -2813,14 +2810,14 @@ namespace tl { /// Returns `u` if `*this` has a value, otherwise an empty optional. template - constexpr optional::type> conjunction(U &&u) const + constexpr optional::type> conjunction(U &&u) const { using result = optional>; return has_value() ? result{u} : result { nullopt }; } template - constexpr optional::type> Conjunction(U &&u) const + constexpr optional::type> Conjunction(U &&u) const { using result = optional>; return has_value() ? result{u} : result { nullopt }; @@ -2990,7 +2987,7 @@ namespace tl { * = nullptr> optional &operator=(U &&u) { - static_assert(std::is_lvalue_reference::value, "U must be an lvalue"); + static_assert(AuIsLValueReference_v, "U must be an lvalue"); m_value = std::addressof(u); return *this; } @@ -3092,8 +3089,8 @@ namespace tl { /// Returns the stored value if there is one, otherwise returns `u` template constexpr T value_or(U &&u) const &noexcept { - static_assert(std::is_copy_constructible::value && - std::is_convertible::value, + static_assert(AuIsCopyConstructible::value && + AuIsConvertible::value, "T must be copy constructible and convertible from U"); return has_value() ? **this : static_cast(AuForward(u)); } @@ -3101,8 +3098,8 @@ namespace tl { /// \group value_or template TL_OPTIONAL_11_CONSTEXPR T value_or(U &&u) && noexcept { - static_assert(std::is_move_constructible::value && - std::is_convertible::value, + static_assert(AuIsMoveConstructible::value && + AuIsConvertible::value, "T must be move constructible and convertible from U"); return has_value() ? **this : static_cast(AuForward(u)); } @@ -3110,8 +3107,8 @@ namespace tl { /// Returns the stored value if there is one, otherwise returns `u` template constexpr T ValueOr(U &&u) const &noexcept { - static_assert(std::is_copy_constructible::value && - std::is_convertible::value, + static_assert(AuIsCopyConstructible::value && + AuIsConvertible::value, "T must be copy constructible and convertible from U"); return has_value() ? **this : static_cast(AuForward(u)); } @@ -3119,8 +3116,8 @@ namespace tl { /// \group value_or template TL_OPTIONAL_11_CONSTEXPR T ValueOr(U &&u) && noexcept { - static_assert(std::is_move_constructible::value && - std::is_convertible::value, + static_assert(AuIsMoveConstructible::value && + AuIsConvertible::value, "T must be move constructible and convertible from U"); return has_value() ? **this : static_cast(AuForward(u)); } @@ -3153,7 +3150,7 @@ namespace std { template struct hash> { - ::std::size_t operator()(const tl::optional &o) const + AuUInt operator()(const tl::optional &o) const { if (!o.has_value()) return 0; diff --git a/Include/auROXTL/auTemplateMeta.hpp b/Include/auROXTL/auTemplateMeta.hpp index 86cf4e0..a688fca 100644 --- a/Include/auROXTL/auTemplateMeta.hpp +++ b/Include/auROXTL/auTemplateMeta.hpp @@ -322,6 +322,7 @@ inline AUROXTL_CONSTEXPR bool AuIsArray_v = true; template using AuEnableIf_t = typename AuEnableIf::type; +#if !defined(AURORA_COMPILER_CLANG) && !defined(AURORA_COMPILER_MSVC) template struct AuIsConstructible { @@ -333,6 +334,17 @@ struct AuIsConstructible template using AuIsConstructible_t = typename AuIsConstructible::type; +#else +template +struct AuIsConstructible : AuBoolType<__is_constructible(T, Args...)> +{ +}; + +template +using AuIsConstructible_t = typename AuIsConstructible::type; + +#endif + template inline AUROXTL_CONSTEXPR bool AuIsConstructible_v = AuIsConstructible::type::value; @@ -593,6 +605,18 @@ namespace _audetail } } #endif + + template + auto test_returnable(int) -> decltype(void(static_cast(nullptr)), AuTrueType {}); + + template + auto test_returnable(...) -> AuFalseType; + + template + auto test_implicitly_convertible(int) -> decltype(void(AuDeclType()(AuDeclType())), AuTrueType {}); + + template + auto test_implicitly_convertible(...) -> AuFalseType; } template @@ -624,4 +648,175 @@ using AuCommonType_t = typename _audetail::common_type::type; return AuForward(std::invoke(f, AuForward(args)...)); } -#endif \ No newline at end of file +#endif + + +template +struct AuIsAssignable : AuBoolType<__is_assignable(T, Z)> +{ }; + +template +constexpr bool AuIsAssignable_v = AuIsAssignable::value; + +template +struct AuIsCopyAssignable : AuIsAssignable, AuAddRReference_t> +{ }; + +template +constexpr bool AuIsCopyAssignable_v = AuIsCopyAssignable::value; + +template +struct AuIsMoveAssignable : AuIsAssignable, AuAddRReference_t> +{ }; + +template +constexpr bool AuIsMoveAssignable_v = AuIsMoveAssignable::value; + +template +struct AuIsTriviallyAssignable : AuBoolType<__is_trivially_assignable(T, Z)> +{ }; + +template +constexpr bool AuIsTriviallyAssignable_v = AuIsTriviallyAssignable::value; + +template +struct AuIsTriviallyCopyAssignable + : AuIsTriviallyAssignable, AuAddRReference_t> +{ }; + +template +constexpr bool AuIsTriviallyCopyAssignable_v = AuIsTriviallyCopyAssignable::value; + +template +struct AuIsTriviallyMoveAssignable + : AuIsTriviallyAssignable, AuAddRReference_t> +{ }; + +template +constexpr bool AuIsTriviallyMoveAssignable_v = AuIsTriviallyMoveAssignable::value; + +template +struct AuIsMoveConstructible : AuIsConstructible +{ }; + +template +constexpr bool AuIsMoveConstructible_v = AuIsMoveConstructible::value; + +template +struct AuIsCopyConstructible : AuIsConstructible> +{ }; + +template +constexpr bool AuIsCopyConstructible_v = AuIsCopyConstructible::value; + +template +struct AuIsDefaultConstructible : AuIsConstructible +{ }; + +template +constexpr bool AuIsDefaultConstructible_v = AuIsDefaultConstructible::value; + +template +struct AuIsTriviallyDestructible : AuBoolType<__is_trivially_destructible(T)> +{ }; + +template +constexpr bool AuIsTriviallyDestructible_v = AuIsTriviallyDestructible::value; + +//template +//struct AuIsConvertible : AuBoolType< +// (decltype(_audetail::test_returnable(0))::value && +// decltype(_audetail::test_implicitly_convertible(0))::value) || +// (AuIsVoid::value && AuIsVoid::value) +//> +//{ }; +template +struct AuIsConvertible : AuBoolType<__is_convertible_to(From, To)> +{ }; + +template +constexpr bool AuIsConvertible_v = AuIsConvertible::value; + +template +struct AuIsNothrowAssignable : AuBoolType<__is_nothrow_assignable(T, Z)> +{ }; + +template +constexpr bool AuIsNothrowAssignable_v = AuIsNothrowAssignable::value; + +template +struct AuIsNothrowCopyAssignable : AuIsNothrowAssignable, AuAddLReference_t> +{ }; + +template +constexpr bool AuIsNothrowCopyAssignable_v = AuIsNothrowCopyAssignable::value; + +template +struct AuIsNothrowMoveAssignable : AuIsNothrowAssignable, T> +{ }; + +template +constexpr bool AuIsNothrowMoveAssignable_v = AuIsNothrowMoveAssignable::value; + +template +struct AuIsTriviallyCopyable : AuBoolType<__is_trivially_copyable(T)> +{ }; + +template +constexpr bool AuIsTriviallyCopyable_v = AuIsTriviallyCopyable::value; + +template +struct AuIsTriviallyConstructible : AuBoolType<__is_trivially_constructible(T, Args...)> +{ }; + +template +constexpr bool AuIsTriviallyConstructible_v = AuIsTriviallyConstructible::value; + +template +struct AuIsTriviallyMoveConstructible : AuIsTriviallyConstructible +{ }; + +template +constexpr bool AuIsTriviallyMoveConstructible_v = AuIsTriviallyMoveConstructible::value; + +template +struct AuIsTriviallyCopyConstructible : AuIsTriviallyConstructible> +{ }; + +template +constexpr bool AuIsTriviallyCopyConstructible_v = AuIsTriviallyCopyConstructible::value; + +template +struct AuIsTriviallyDefaultConstructible : AuIsTriviallyConstructible +{ }; + +template +constexpr bool AuIsTriviallyDefaultConstructible_v = AuIsTriviallyDefaultConstructible::value; + +template +struct AuIsNothrowConstructible : AuBoolType<__is_nothrow_constructible(T, Args...)> +{ }; + +template +constexpr bool AuIsNothrowConstructible_v = AuIsNothrowConstructible::value; + +template +struct AuIsNothrowMoveConstructible : AuIsNothrowConstructible +{ }; + +template +constexpr bool AuIsNothrowMoveConstructible_v = AuIsNothrowMoveConstructible::value; + +template +struct AuIsNothrowCopyConstructible : AuIsNothrowConstructible> +{ }; + +template +constexpr bool AuIsNothrowCopyConstructible_v = AuIsNothrowCopyConstructible::value; + +template +struct AuIsNothrowDefaultConstructible : AuIsNothrowConstructible +{ }; + +template +constexpr bool AuIsNothrowDefaultConstructible_v = AuIsNothrowDefaultConstructible::value; \ No newline at end of file