type_traits.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_TYPEINFO_TYPE_TRAITS_HPP__
#define NEFORCE_CORE_TYPEINFO_TYPE_TRAITS_HPP__

 
#include "NeForce/core/typeinfo/types.hpp"
NEFORCE_BEGIN_NAMESPACE__



template <typename T, T Value>
struct integral_constant {
    static constexpr T value = Value; 
 
    using value_type = T;                     
    using type = integral_constant<T, Value>; 

    constexpr explicit operator value_type() const noexcept { return value; }

    NEFORCE_NODISCARD constexpr value_type operator()() const noexcept { return value; }
};
 

template <bool Value>
using bool_constant = integral_constant<bool, Value>;
 
using true_type = bool_constant<true>;   
using false_type = bool_constant<false>; 

template <uint32_t Value>
using uint32_constant = integral_constant<uint32_t, Value>;

template <uint64_t Value>
using uint64_constant = integral_constant<uint64_t, Value>;
 

template <typename... Types>
using void_t = void;

template <bool Test, typename T = void>
struct enable_if {};

template <typename T>
struct enable_if<true, T> {
    using type = T;
};

template <bool Test, typename T = void>
using enable_if_t = typename enable_if<Test, T>::type;
 

template <bool Test, typename T1, typename T2>
struct conditional {
    using type = T1;
};

template <typename T1, typename T2>
struct conditional<false, T1, T2> {
    using type = T2;
};

template <bool Test, typename T1, typename T2>
using conditional_t = typename conditional<Test, T1, T2>::type;
 

template <typename T>
struct negation : bool_constant<!static_cast<bool>(T::value)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool negation_v = negation<T>::value;
#endif
 

template <typename T1, typename T2>
struct is_same : false_type {};

template <typename T>
struct is_same<T, T> : true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T1, typename T2>
NEFORCE_INLINE17 constexpr bool is_same_v = is_same<T1, T2>::value;
#endif
 

template <typename T>
struct type_identity {
    using type = T;
};

template <typename T>
using type_identity_t = typename type_identity<T>::type;
 

template <typename T, typename... Types>
struct is_any_of;
 
#ifdef NEFORCE_STANDARD_17
template <typename T, typename... Types>
struct is_any_of : bool_constant<(is_same_v<T, Types> || ...)> {};
#else
template <typename T, typename... Types>
struct is_any_of : false_type {};

template <typename T, typename U>
struct is_any_of<T, U> : is_same<T, U> {};
 
template <typename T, typename U, typename... Types>
struct is_any_of<T, U, Types...> : conditional<is_same<T, U>::value, true_type, is_any_of<T, Types...>>::type {};
#endif // NEFORCE_STANDARD_17
 
#ifdef NEFORCE_STANDARD_14
template <typename T, typename... Types>
NEFORCE_INLINE17 constexpr bool is_any_of_v = is_any_of<T, Types...>::value;
#endif
 

NEFORCE_BEGIN_INNER__
// 析取辅助实现
template <bool, typename first, typename...>
struct __disjunction_aux {
    using type = first;
};
template <typename Curr, typename Next, typename... Rest>
struct __disjunction_aux<false, Curr, Next, Rest...> {
    using type = typename __disjunction_aux<static_cast<bool>(Next::value), Next, Rest...>::type;
};
NEFORCE_END_INNER__

template <typename... Args>
struct disjunction : false_type {};

template <typename First, typename... Rest>
struct disjunction<First, Rest...> : inner::__disjunction_aux<static_cast<bool>(First::value), First, Rest...>::type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename... Args>
NEFORCE_INLINE17 constexpr bool disjunction_v = disjunction<Args...>::value;
#endif
 

NEFORCE_BEGIN_INNER__
// 合取辅助实现
template <bool, typename First, typename...>
struct __conjunction_aux {
    using type = First;
};
template <typename Curr, typename Next, typename... Rest>
struct __conjunction_aux<true, Curr, Next, Rest...> {
    using type = typename __conjunction_aux<static_cast<bool>(Next::value), Next, Rest...>::type;
};
NEFORCE_END_INNER__

template <typename... Args>
struct conjunction : true_type {};

template <typename First, typename... Rest>
struct conjunction<First, Rest...> : inner::__conjunction_aux<static_cast<bool>(First::value), First, Rest...>::type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename... Args>
NEFORCE_INLINE17 constexpr bool conjunction_v = conjunction<Args...>::value;
#endif
 // TypeTraitsUtilities


template <typename T>
struct remove_const {
    using type = T;
};

template <typename T>
struct remove_const<const T> {
    using type = T;
};

template <typename T>
using remove_const_t = typename remove_const<T>::type;
 

template <typename T>
struct remove_volatile {
    using type = T;
};

template <typename T>
struct remove_volatile<volatile T> {
    using type = T;
};

template <typename T>
using remove_volatile_t = typename remove_volatile<T>::type;
 

template <typename T>
struct remove_cv {
    using type = T;

    template <typename wrapper>
    using bind_cv_t = wrapper;
};

template <typename T>
struct remove_cv<const T> {
    using type = T;
 
    template <typename wrapper>
    using bind_cv_t = const wrapper;
};
 
template <typename T>
struct remove_cv<volatile T> {
    using type = T;
 
    template <typename wrapper>
    using bind_cv_t = volatile wrapper;
};
 
template <typename T>
struct remove_cv<const volatile T> {
    using type = T;
 
    template <typename wrapper>
    using bind_cv_t = const volatile wrapper;
};

template <typename T>
using remove_cv_t = typename remove_cv<T>::type;

template <typename From, typename To>
using copy_cv_t = typename remove_cv<From>::template bind_cv_t<To>;
 

template <typename T>
struct remove_reference {
    using type = T;

    template <typename wrapper>
    using bind_ref_t = wrapper;
};

template <typename T>
struct remove_reference<T&> {
    using type = T;
 
    template <typename wrapper>
    using bind_ref_t = wrapper&;
};
 
template <typename T>
struct remove_reference<T&&> {
    using type = T;
 
    template <typename wrapper>
    using bind_ref_t = wrapper&&;
};

template <typename T>
using remove_reference_t = typename remove_reference<T>::type;

template <typename From, typename To>
using copy_ref_t = typename remove_reference<From>::template bind_ref_t<To>;

template <typename From, typename To>
using copy_cvref_t = copy_ref_t<From, copy_cv_t<From, To>>;
 

template <typename T>
struct remove_cvref {
    using type = remove_cv_t<remove_reference_t<T>>;
};

template <typename T>
using remove_cvref_t = typename remove_cvref<T>::type;
 

template <typename T>
struct remove_extent {
    using type = T;
};

template <typename T, size_t Idx>
struct remove_extent<T[Idx]> {
    using type = T;
};
 
template <typename T>
struct remove_extent<T[]> {
    using type = T;
};

template <typename T>
using remove_extent_t = typename remove_extent<T>::type;
 

template <typename T>
struct remove_all_extents {
    using type = T;
};

template <typename T, size_t Idx>
struct remove_all_extents<T[Idx]> {
    using type = typename remove_all_extents<T>::type;
};
 
template <typename T>
struct remove_all_extents<T[]> {
    using type = typename remove_all_extents<T>::type;
};

template <typename T>
using remove_all_extents_t = typename remove_all_extents<T>::type;
 

template <typename T>
struct remove_pointer {
    using type = T;

    template <typename wrapper>
    using bind_pointer_t = wrapper;
};

template <typename T>
struct remove_pointer<T*> {
    using type = T;
 
    template <typename wrapper>
    using bind_pointer_t = wrapper*;
};
 
template <typename T>
struct remove_pointer<T* const> {
    using type = T;
 
    template <typename wrapper>
    using bind_pointer_t = const wrapper*;
};
 
template <typename T>
struct remove_pointer<T* volatile> {
    using type = T;
 
    template <typename wrapper>
    using bind_pointer_t = volatile wrapper*;
};
 
template <typename T>
struct remove_pointer<T* const volatile> {
    using type = T;
 
    template <typename wrapper>
    using bind_pointer_t = volatile const wrapper*;
};

template <typename T>
using remove_pointer_t = typename remove_pointer<T>::type;

template <typename From, typename To>
using copy_pointer_t = typename remove_pointer<From>::template bind_pointer_t<To>;
 

template <typename T>
struct remove_function_qualifiers {
    using type = T;
};

 
template <typename Ret, typename... Args>
struct remove_function_qualifiers<Ret(Args...)> {
    using type = Ret(Args...);
};
 
#define __NEFORCE_EXPAND_REM_FUNC_QULF(QUF)               \
    template <typename Ret, typename... Args>             \
    struct remove_function_qualifiers<Ret(Args...) QUF> { \
        using type = Ret(Args...);                        \
    };
 
NEFORCE_MACRO_RANGES_CV(__NEFORCE_EXPAND_REM_FUNC_QULF)
NEFORCE_MACRO_RANGES_CV_REF(__NEFORCE_EXPAND_REM_FUNC_QULF)
#ifdef NEFORCE_STANDARD_17
NEFORCE_MACRO_RANGES_CV_REF_NOEXCEPT(__NEFORCE_EXPAND_REM_FUNC_QULF)
#endif
#undef __NEFORCE_EXPAND_REM_FUNC_QULF


template <typename T>
using remove_function_qualifiers_t = typename remove_function_qualifiers<T>::type;
 // RemoveQualifiers


NEFORCE_BEGIN_INNER__
template <typename>
struct __is_void_helper : false_type {};
 
template <>
struct __is_void_helper<void> : true_type {};
NEFORCE_END_INNER__

template <typename T>
struct is_void : inner::__is_void_helper<remove_cv_t<T>>::type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_void_v = is_void<T>::value;
#endif
 

template <typename T, typename Dummy = void>
struct package {
    using type = T;
};

template <typename T>
using package_t = typename package<T>::type;

template <typename T>
struct is_packaged : bool_constant<!is_same<package_t<T>, T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_packaged_v = is_packaged<T>::value;
#endif

template <typename T, typename Dummy = void>
struct unpackage {
    using type = T;
};

template <typename T>
using unpackage_t = typename unpackage<T>::type;

template <typename T>
using unpack_remove_cvref_t = unpackage_t<remove_cvref_t<T>>;

template <typename T>
struct is_unpackaged : bool_constant<!is_same<unpackage_t<T>, T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_unpackaged_v = is_unpackaged<T>::value;
#endif
 

template <typename T>
struct is_character : bool_constant<is_any_of<remove_cvref_t<T>, char, wchar_t,
#ifdef NEFORCE_STANDARD_20
                                              char8_t,
#endif
                                              char16_t, char32_t>::value> {
};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_character_v = is_character<T>::value;
#endif
 

template <typename T>
struct is_boolean : bool_constant<is_same<remove_cvref_t<T>, bool>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_boolean_v = is_boolean<T>::value;
#endif
 

template <typename T>
struct is_standard_integral
: bool_constant<is_any_of<remove_cvref_t<T>, signed char, short, int, long, long long, unsigned char, unsigned short,
                          unsigned int, unsigned long, unsigned long long>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_standard_integral_v = is_standard_integral<T>::value;
#endif
 

template <typename T>
struct is_integral : bool_constant<disjunction<is_standard_integral<T>, is_character<T>, is_boolean<T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_integral_v = is_integral<T>::value;
#endif
 

template <typename T>
struct is_floating_point : bool_constant<is_any_of<remove_cvref_t<T>, float, double, long double>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_floating_point_v = is_floating_point<T>::value;
#endif
 

template <typename T>
struct is_arithmetic : bool_constant<disjunction<is_integral<T>, is_floating_point<T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
#endif
 

NEFORCE_BEGIN_INNER__
template <typename T, bool = is_integral<T>::value>
struct __check_sign_aux {
    static constexpr bool is_signed = static_cast<remove_cvref_t<T>>(-1) < static_cast<remove_cv_t<T>>(0);
    static constexpr bool is_unsigned = !is_signed;
};
 
template <typename T>
struct __check_sign_aux<T, false> {
    static constexpr bool is_signed = is_floating_point<T>::value;
    static constexpr bool is_unsigned = false;
};
NEFORCE_END_INNER__

template <typename T>
struct is_signed : bool_constant<inner::__check_sign_aux<unpack_remove_cvref_t<T>>::is_signed> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_signed_v = is_signed<T>::value;
#endif

template <typename T>
struct is_unsigned : bool_constant<inner::__check_sign_aux<unpack_remove_cvref_t<T>>::is_unsigned> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_unsigned_v = is_unsigned<T>::value;
#endif
 // TypeProperties


template <typename T>
struct add_const {
    using type = const T;
};

template <typename T>
using add_const_t = typename add_const<T>::type;

template <typename T>
NEFORCE_NODISCARD constexpr add_const_t<T>& as_const(T& val) noexcept {
    return val;
}

template <typename T>
void as_const(const T&&) = delete;

template <typename T>
struct add_volatile {
    using type = volatile T;
};

template <typename T>
using add_volatile_t = typename add_volatile<T>::type;

template <typename T>
struct add_cv {
    using type = const volatile T;
};

template <typename T>
using add_cv_t = typename add_cv<T>::type;
 

template <typename T, typename Dummy = void>
struct add_reference {
    using lvalue = T;
    using rvalue = T;
};

template <typename T>
struct add_reference<T, void_t<T&>> {
    using lvalue = T&;
    using rvalue = T&&;
};

template <typename T>
struct add_lvalue_reference {
    using type = typename add_reference<T>::lvalue;
};

template <typename T>
using add_lvalue_reference_t = typename add_reference<T>::lvalue;

template <typename T>
struct add_rvalue_reference {
    using type = typename add_reference<T>::rvalue;
};

template <typename T>
using add_rvalue_reference_t = typename add_reference<T>::rvalue;
 

template <typename T, typename Dummy = void>
struct add_pointer {
    using type = T;
};

template <typename T>
struct add_pointer<T, void_t<remove_reference_t<T>*>> {
    using type = remove_reference_t<T>*;
};

template <typename T>
using add_pointer_t = typename add_pointer<T>::type;
 // AddQualifiers


template <typename T>
add_rvalue_reference_t<T> declval() noexcept;
 
template <typename T>
add_lvalue_reference_t<T> ldeclval() noexcept;

template <typename T>
type_identity_t<T> declcopy(type_identity_t<T>) noexcept;

template <typename T>
void declvoid(type_identity_t<T>) noexcept;
 // DeclvalTools


template <typename T>
struct rank : integral_constant<size_t, 0> {};

template <typename T, size_t Idx>
struct rank<T[Idx]> : integral_constant<size_t, rank<T>::value + 1> {};
 
template <typename T>
struct rank<T[]> : integral_constant<size_t, rank<T>::value + 1> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr size_t rank_v = rank<T>::value;
#endif
 

template <typename T, uint32_t Idx = 0>
struct extent : integral_constant<size_t, 0> {};

template <typename T, size_t N>
struct extent<T[N], 0> : integral_constant<size_t, N> {};
 
template <typename T, uint32_t Idx, size_t N>
struct extent<T[N], Idx> : extent<T, Idx - 1> {};
 
template <typename T, uint32_t Idx>
struct extent<T[], Idx> : extent<T, Idx - 1> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T, uint32_t Idx = 0>
NEFORCE_INLINE17 constexpr size_t extent_v = extent<T, Idx>::value;
#endif
 // ArrayProperties


template <typename T>
struct get_first_temp_para;

template <template <typename, typename...> class T, typename First, typename... Rest>
struct get_first_temp_para<T<First, Rest...>> {
    using type = First;
};

template <typename Tmp>
using get_first_temp_para_t = typename get_first_temp_para<Tmp>::type;
 

template <typename... Types>
struct get_first_para;

template <typename First, typename... Rest>
struct get_first_para<First, Rest...> {
    using type = First;
};

template <typename... Types>
using get_first_para_t = typename get_first_para<Types...>::type;
 

template <typename T, typename Dummy = void>
struct get_ptr_difference {
    using type = ptrdiff_t;
};

template <typename T>
struct get_ptr_difference<T, enable_if_t<is_same<typename T::difference_type, typename T::difference_type>::value>> {
    using type = typename T::difference_type;
};

template <typename T>
using get_ptr_difference_t = typename get_ptr_difference<T>::type;
 

template <typename NewFirst, typename T>
struct replace_first_para;

template <typename NewFirst, template <typename, typename...> class T, typename First, typename... Rest>
struct replace_first_para<NewFirst, T<First, Rest...>> {
    using type = T<NewFirst, Rest...>;
};

template <typename T, typename U>
using replace_first_para_t = typename replace_first_para<T, U>::type;
 

template <typename T, typename U, typename Dummy = void>
struct get_rebind_type {
    using type = replace_first_para_t<U, T>;
};

template <typename T, typename U>
struct get_rebind_type<T, U,
                       enable_if_t<is_same<typename T::template rebind<U>, typename T::template rebind<U>>::value>> {
    using type = typename T::template rebind<U>;
};

template <typename T, typename U>
using get_rebind_type_t = typename get_rebind_type<T, U>::type;
 // TemplateTraitsUtilities


template <typename T>
struct is_bounded_array : false_type {};

template <typename T, size_t Idx>
struct is_bounded_array<T[Idx]> : true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_bounded_array_v = is_bounded_array<T>::value;
#endif
 

template <typename T>
struct is_unbounded_array : false_type {};

template <typename T>
struct is_unbounded_array<T[]> : true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
#endif

template <typename T>
struct is_array : bool_constant<is_unbounded_array<T>::value || is_bounded_array<T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_array_v = is_array<T>::value;
#endif
 

template <typename T>
struct is_lvalue_reference : false_type {};

template <typename T>
struct is_lvalue_reference<T&> : true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
#endif

template <typename T>
struct is_rvalue_reference : false_type {};

template <typename T>
struct is_rvalue_reference<T&&> : true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value;
#endif
 

template <typename T>
struct is_reference : bool_constant<is_lvalue_reference<T>::value || is_rvalue_reference<T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_reference_v = is_reference<T>::value;
#endif
 

template <typename T>
struct is_null_pointer : bool_constant<is_same<remove_cvref_t<T>, nullptr_t>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
#endif
 

template <typename T>
struct is_pointer : false_type {};

template <typename T>
struct is_pointer<T*> : true_type {};
 
template <typename T>
struct is_pointer<T* const> : true_type {};
 
template <typename T>
struct is_pointer<T* volatile> : true_type {};
 
template <typename T>
struct is_pointer<T* const volatile> : true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_pointer_v = is_pointer<T>::value;
#endif
 

template <typename T>
struct is_enum : bool_constant<__is_enum(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_enum_v = is_enum<T>::value;
#endif
 

template <typename T>
struct is_integral_like : bool_constant<disjunction<is_integral<T>, is_enum<T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_integral_like_v = is_integral_like<T>::value;
#endif
 

template <typename T>
struct is_union : bool_constant<__is_union(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_union_v = is_union<T>::value;
#endif
 

template <typename T>
struct is_class : bool_constant<__is_class(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_class_v = is_class<T>::value;
#endif
 

template <typename T>
struct is_fundamental : bool_constant<disjunction<is_arithmetic<T>, is_void<T>, is_null_pointer<T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_fundamental_v = is_fundamental<T>::value;
#endif
 

template <typename T>
struct is_compound : bool_constant<!is_fundamental<T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_compound_v = is_compound<T>::value;
#endif
 

template <typename T>
struct is_const : false_type {};

template <typename T>
struct is_const<const T> : true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_const_v = is_const<T>::value;
#endif
 

template <typename T>
struct is_volatile : false_type {};

template <typename T>
struct is_volatile<volatile T> : true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_volatile_v = is_volatile<T>::value;
#endif
 
 
#ifdef NEFORCE_COMPILER_MSVC
// 禁用MSVC警告4180：从const限定的函数类型中移除const
#    pragma warning(push)
#    pragma warning(disable : 4180)
#endif

template <typename T>
struct is_function : bool_constant<!is_const<const remove_function_qualifiers_t<T>>::value &&
                                   !is_reference<remove_function_qualifiers_t<T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_function_v = is_function<T>::value;
#endif
 
#ifdef NEFORCE_COMPILER_MSVC
#    pragma warning(pop)
#endif
 

template <typename T>
struct is_allocable
: bool_constant<!(is_void<T>::value || is_reference<T>::value || is_function<T>::value || is_const<T>::value) &&
                (sizeof(T) > 0)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_allocable_v = is_allocable<T>::value;
#endif
 

template <typename T>
struct is_object : bool_constant<is_const<const T>::value && !is_void<T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_object_v = is_object<T>::value;
#endif
 

template <typename T>
struct is_cstring
: bool_constant<(is_pointer<remove_cvref_t<T>>::value && is_character<remove_pointer_t<remove_cvref_t<T>>>::value) ||
                (is_bounded_array<remove_cvref_t<T>>::value &&
                 is_character<remove_all_extents_t<remove_cvref_t<T>>>::value)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
constexpr bool is_cstring_v = is_cstring<T>::value;
#endif
 

template <typename T>
struct is_member_function_pointer;

#ifdef NEFORCE_COMPILER_CLANG
template <typename T>
struct is_member_function_pointer : bool_constant<__is_member_function_pointer(T)> {};
#else
NEFORCE_BEGIN_INNER__
template <typename>
struct __is_member_function_pointer_aux : false_type {};
template <typename T, typename C>
struct __is_member_function_pointer_aux<T C::*> : is_function<T> {};
NEFORCE_END_INNER__
 
template <typename T>
struct is_member_function_pointer : inner::__is_member_function_pointer_aux<remove_cv_t<T>> {};
#endif
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_member_function_pointer_v = is_member_function_pointer<T>::value;
#endif
 

template <typename T>
struct is_member_object_pointer;

#ifdef NEFORCE_COMPILER_CLANG
template <typename T>
struct is_member_object_pointer : bool_constant<__is_member_object_pointer(T)> {};
#else
template <typename T>
struct is_member_object_pointer : false_type {};
template <typename T, typename C>
struct is_member_object_pointer<T C::*> : bool_constant<!is_function<T>::value> {};
#endif
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_member_object_pointer_v = is_member_object_pointer<remove_cv_t<T>>::value;
#endif
 

template <typename T>
struct is_member_pointer;

#ifdef NEFORCE_COMPILER_CLANG
template <typename T>
struct is_member_pointer : bool_constant<__is_member_pointer(T)> {};
#else
template <typename T>
struct is_member_pointer : bool_constant<is_member_object_pointer<T>::value || is_member_function_pointer<T>::value> {};
#endif
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
#endif
 

template <typename T>
struct is_scalar
: bool_constant<
          disjunction<is_arithmetic<T>, is_enum<T>, is_pointer<T>, is_member_pointer<T>, is_null_pointer<T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_scalar_v = is_scalar<T>::value;
#endif
 

template <typename T>
struct is_empty : bool_constant<__is_empty(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_empty_v = is_empty<T>::value;
#endif
 

template <typename T>
struct is_polymorphic : bool_constant<__is_polymorphic(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_polymorphic_v = is_polymorphic<T>::value;
#endif
 

template <typename T>
struct is_abstract : bool_constant<__is_abstract(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_abstract_v = is_abstract<T>::value;
#endif
 

template <typename T>
struct is_final : bool_constant<__is_final(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_final_v = is_final<T>::value;
#endif
 

NEFORCE_BEGIN_INNER__
template <typename T, bool = is_enum<T>::value>
struct __underlying_type_aux {
    using type = __underlying_type(T);
};
template <typename T>
struct __underlying_type_aux<T, false> {};
NEFORCE_END_INNER__

template <typename T>
struct underlying_type : inner::__underlying_type_aux<T> {};

template <typename T>
using underlying_type_t = typename underlying_type<T>::type;
 

template <typename T>
struct is_standard_layout : bool_constant<__is_standard_layout(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_standard_layout_v = is_standard_layout<T>::value;
#endif
 

template <typename T>
struct is_pod : bool_constant<__is_pod(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_pod_v = is_pod<T>::value;
#endif
 

template <typename T>
struct has_unique_object_representations : bool_constant<__has_unique_object_representations(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool has_unique_object_representations_v = has_unique_object_representations<T>::value;
#endif
 

template <typename T>
struct is_aggregate;

#ifdef NEFORCE_COMPILER_MSVC
template <typename T>
struct is_aggregate : bool_constant<is_array<T>::value || __is_aggregate(T)> {};
#else
template <typename T>
struct is_aggregate : bool_constant<__is_aggregate(remove_cv_t<T>)> {};
#endif
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_aggregate_v = is_aggregate<T>::value;
#endif
 
 
#ifdef NEFORCE_COMPILER_MSVC
template <typename T1, typename T2>
struct is_layout_compatible : bool_constant<__is_layout_compatible(T1, T2)> {};

#    ifdef NEFORCE_STANDARD_14
template <typename T1, typename T2>
NEFORCE_INLINE17 constexpr bool is_layout_compatible_v = is_layout_compatible<T1, T2>::value;
#    endif
 

template <typename Base, typename Derived>
struct is_pointer_interconvertible_base_of : bool_constant<__is_pointer_interconvertible_base_of(Base, Derived)> {};
 
#    ifdef NEFORCE_STANDARD_14
template <typename Base, typename Derived>
NEFORCE_INLINE17 constexpr bool is_pointer_interconvertible_base_of_v =
        is_pointer_interconvertible_base_of<Base, Derived>::value;
#    endif
#endif
 

template <typename Base, typename Derived>
struct is_base_of : bool_constant<__is_base_of(Base, Derived)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename Base, typename Derived>
NEFORCE_INLINE17 constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
#endif
 
 
#ifdef NEFORCE_STANDARD_20
template <typename T, typename Mem>
constexpr bool is_pointer_interconvertible_with_class(Mem T::* mp) noexcept {
    return __builtin_is_pointer_interconvertible_with_class(mp);
}

template <typename S1, typename S2, typename M1, typename M2>
constexpr bool is_corresponding_member(M1 S1::* m1, M2 S2::* m2) noexcept {
    return __builtin_is_corresponding_member(m1, m2);
}
#endif
 // BaseTypeQualifierCheck


template <typename T>
struct is_trivial : bool_constant<__is_trivial(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_trivial_v = is_trivial<T>::value;
#endif
 

template <typename T>
struct is_trivially_copyable : bool_constant<__is_trivially_copyable(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
#endif
 

template <typename T>
struct has_virtual_destructor : bool_constant<__has_virtual_destructor(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool has_virtual_destructor_v = has_virtual_destructor<T>::value;
#endif
 

template <typename T, typename... Args>
struct is_constructible : bool_constant<__is_constructible(T, Args...)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T, typename... Args>
NEFORCE_INLINE17 constexpr bool is_constructible_v = is_constructible<T, Args...>::value;
#endif
 

template <typename T>
struct is_copy_constructible : bool_constant<is_constructible<T, add_lvalue_reference_t<const T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_copy_constructible_v = is_copy_constructible<T>::value;
#endif
 

template <typename T>
struct is_default_constructible : bool_constant<is_constructible<T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_default_constructible_v = is_default_constructible<T>::value;
#endif
 

NEFORCE_BEGIN_INNER__
template <typename T>
void __implicitly_default_construct_aux(const T&) noexcept;
NEFORCE_END_INNER__

template <typename T, typename Dummy = void>
struct is_implicitly_default_constructible : false_type {};

template <typename T>
struct is_implicitly_default_constructible<T, void_t<decltype(inner::__implicitly_default_construct_aux<T>({}))>>
: true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_implicitly_default_constructible_v = is_implicitly_default_constructible<T>::value;
#endif
 

template <typename T>
struct is_move_constructible : bool_constant<is_constructible<T, T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_move_constructible_v = is_move_constructible<T>::value;
#endif
 

template <typename To, typename From>
struct is_assignable : bool_constant<__is_assignable(To, From)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename To, typename From>
NEFORCE_INLINE17 constexpr bool is_assignable_v = is_assignable<To, From>::value;
#endif
 

template <typename T>
struct is_copy_assignable
: bool_constant<is_assignable<add_lvalue_reference_t<T>, add_lvalue_reference_t<const T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_copy_assignable_v = is_copy_assignable<T>::value;
#endif
 

template <typename T>
struct is_move_assignable : bool_constant<is_assignable<add_lvalue_reference_t<T>, T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_move_assignable_v = is_move_assignable<T>::value;
#endif
 

template <typename T>
struct is_destructible;

#ifdef NEFORCE_COMPILER_MSVC
template <typename T>
struct is_destructible : bool_constant<__is_destructible(T)> {};
#else
NEFORCE_BEGIN_INNER__
template <typename T>
struct __destructible_aux {
private:
    template <typename T1, typename = decltype(declval<T1&>().~T1())>
    static true_type __test(int);
    template <typename>
    static false_type __test(...);
 
public:
    using type = decltype(__test<T>(0));
};
 
template <typename T, bool = disjunction<is_void<T>, is_unbounded_array<T>, is_function<T>>::value,
          bool = disjunction<is_reference<T>, is_scalar<T>>::value>
struct __is_destructible_dispatch;
 
template <typename T>
struct __is_destructible_dispatch<T, false, false> : __destructible_aux<remove_all_extents_t<T>>::type {};
 
template <typename T>
struct __is_destructible_dispatch<T, true, false> : false_type {};
 
template <typename T>
struct __is_destructible_dispatch<T, false, true> : true_type {};
 
NEFORCE_END_INNER__
 
template <typename T>
struct is_destructible : inner::__is_destructible_dispatch<T>::type {};
#endif
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_destructible_v = is_destructible<T>::value;
#endif
 

template <typename T, typename... Args>
struct is_trivially_constructible : bool_constant<__is_trivially_constructible(T, Args...)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T, typename... Args>
NEFORCE_INLINE17 constexpr bool is_trivially_constructible_v = is_trivially_constructible<T, Args...>::value;
#endif
 

template <typename T>
struct is_trivially_copy_constructible
: bool_constant<is_trivially_constructible<T, add_lvalue_reference_t<const T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<T>::value;
#endif
 

template <typename T>
struct is_trivially_default_constructible : bool_constant<is_trivially_constructible<T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_trivially_default_constructible_v = is_trivially_default_constructible<T>::value;
#endif
 

template <typename T>
struct is_trivially_move_constructible : bool_constant<is_trivially_constructible<T, T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<T>::value;
#endif
 

template <typename To, typename From>
struct is_trivially_assignable : bool_constant<__is_trivially_assignable(To, From)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename To, typename From>
NEFORCE_INLINE17 constexpr bool is_trivially_assignable_v = is_trivially_assignable<To, From>::value;
#endif
 

template <typename T>
struct is_trivially_copy_assignable
: bool_constant<is_trivially_assignable<add_lvalue_reference_t<T>, add_lvalue_reference_t<const T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<T>::value;
#endif
 

template <typename T>
struct is_trivially_move_assignable : bool_constant<is_trivially_assignable<add_lvalue_reference_t<T>, T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<T>::value;
#endif
 

template <typename T>
struct is_trivially_destructible :
#if defined(NEFORCE_COMPILER_MSVC) || defined(NEFORCE_COMPILER_CLANG)
        bool_constant<__is_trivially_destructible(T)> {
};
#else
        conjunction<is_destructible<T>, bool_constant<__has_trivial_destructor(T)>> {
};
#endif
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_trivially_destructible_v = is_trivially_destructible<T>::value;
#endif
 

template <typename T, typename... Args>
struct is_nothrow_constructible;

template <typename T>
struct is_nothrow_default_constructible;

#ifdef NEFORCE_COMPILER_MSVC
template <typename T, typename... Args>
struct is_nothrow_constructible : bool_constant<__is_nothrow_constructible(T, Args...)> {};
#else
NEFORCE_BEGIN_INNER__
template <typename T, bool = is_array<T>::value>
struct __is_nothrow_default_constructible_dispatch;
 
template <typename T>
struct __is_nothrow_default_constructible_dispatch<T, true>
: conjunction<is_bounded_array<T>, bool_constant<noexcept(remove_all_extents_t<T>())>> {};
 
template <typename T>
struct __is_nothrow_default_constructible_dispatch<T, false> : bool_constant<noexcept(T())> {};
 
NEFORCE_END_INNER__
 
template <typename T>
struct is_nothrow_default_constructible
: conjunction<is_default_constructible<T>, inner::__is_nothrow_default_constructible_dispatch<T>> {};
 
NEFORCE_BEGIN_INNER__
 
template <typename T, typename... Args>
struct __is_nothrow_constructible_dispatch : bool_constant<noexcept(T(_NEFORCE declval<Args>()...))> {};
 
template <typename T>
struct __is_nothrow_constructible_dispatch<T> : is_nothrow_default_constructible<T> {};
 
NEFORCE_END_INNER__
 
template <typename T, typename... Args>
struct is_nothrow_constructible
: conjunction<is_constructible<T, Args...>, inner::__is_nothrow_constructible_dispatch<T, Args...>> {};
#endif
 
#ifdef NEFORCE_STANDARD_14
template <typename T, typename... Args>
NEFORCE_INLINE17 constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<T, Args...>::value;
#endif
 

template <typename T>
struct is_nothrow_copy_constructible
: bool_constant<is_nothrow_constructible<T, add_lvalue_reference_t<const T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<T>::value;
#endif
 

#ifdef NEFORCE_COMPILER_MSVC
template <typename T>
struct is_nothrow_default_constructible : bool_constant<is_nothrow_constructible_v<T>> {};
#endif
 
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_nothrow_default_constructible_v = is_nothrow_default_constructible<T>::value;
#endif
 

template <typename T>
struct is_nothrow_move_constructible : bool_constant<is_nothrow_constructible<T, T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<T>::value;
#endif
 

template <typename To, typename From>
struct is_nothrow_assignable;

template <typename To, typename From>
struct is_nothrow_assignable : bool_constant<__is_nothrow_assignable(To, From)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename To, typename From>
NEFORCE_INLINE17 constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<To, From>::value;
#endif
 

template <typename T>
struct is_nothrow_copy_assignable
: bool_constant<is_nothrow_assignable<add_lvalue_reference_t<T>, add_lvalue_reference_t<const T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<T>::value;
#endif
 

template <typename T>
struct is_nothrow_move_assignable : bool_constant<is_nothrow_assignable<add_lvalue_reference_t<T>, T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<T>::value;
#endif
 
 
#ifndef NEFORCE_COMPILER_MSVC
NEFORCE_BEGIN_INNER__
template <typename T>
struct __is_nothrow_destructible_aux {
private:
    template <typename T1>
    static bool_constant<noexcept(declval<T1&>().~T1())> __test(int);
 
    template <typename>
    static false_type __test(...);
 
public:
    using type = decltype(__test<T>(0));
};
 
template <typename T, bool = disjunction<is_void<T>, is_unbounded_array<T>, is_function<T>>::value,
          bool = disjunction<is_reference<T>, is_scalar<T>>::value>
struct __is_nothrow_destructible_dispatch;
 
template <typename T>
struct __is_nothrow_destructible_dispatch<T, false, false>
: __is_nothrow_destructible_aux<remove_all_extents_t<T>>::type {};
 
template <typename T>
struct __is_nothrow_destructible_dispatch<T, true, false> : false_type {};
 
template <typename T>
struct __is_nothrow_destructible_dispatch<T, false, true> : true_type {};
NEFORCE_END_INNER__
#endif
 

template <typename T>
struct is_nothrow_destructible;

template <typename T>
struct is_nothrow_destructible :
#ifdef NEFORCE_COMPILER_MSVC
        bool_constant<__is_nothrow_destructible(T)> {
};
#else
        inner::__is_nothrow_destructible_dispatch<T>::type {
};
#endif
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<T>::value;
#endif
 

template <typename T>
struct is_location_invariant : is_trivially_copyable<T>::type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_location_invariant_v = is_location_invariant<T>::value;
#endif
 // TypeSpecialMemberFunctionChecks


template <typename T>
NEFORCE_NODISCARD constexpr T&& forward(remove_reference_t<T>& x) noexcept {
    return static_cast<T&&>(x);
}

template <typename T>
NEFORCE_NODISCARD constexpr T&& forward(remove_reference_t<T>&& x) noexcept {
    static_assert(!is_lvalue_reference<T>::value, "forward failed.");
    return static_cast<T&&>(x);
}

template <typename T>
NEFORCE_NODISCARD constexpr remove_reference_t<T>&& move(T&& x) noexcept {
    return static_cast<remove_reference_t<T>&&>(x);
}

template <typename T>
NEFORCE_NODISCARD constexpr conditional_t<!is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
                                          const T&, T&&>
move_if_noexcept(T& x) noexcept {
    return _NEFORCE move(x);
}

template <typename T>
NEFORCE_NODISCARD constexpr T* addressof(T& x) noexcept {
    return __builtin_addressof(x);
}

template <typename T>
const T* addressof(const T&&) = delete;
 
 
template <typename T, typename U>
constexpr size_t offset_of(U T::* member) {
    return reinterpret_cast<size_t>(&(reinterpret_cast<T const volatile*>(nullptr)->*member));
}
 
 // ArgsForwardFunctions

 
#if !defined(NEFORCE_COMPILER_MSVC) && !defined(NEFORCE_COMPILER_CLANG)
NEFORCE_BEGIN_INNER__
template <typename From, typename To, bool = disjunction_v<is_void<From>, is_function<To>, is_array<To>>>
struct __is_convertible_helper {
    using type = typename is_void<To>::type;
};
 
template <typename From, typename To>
struct __is_convertible_helper<From, To, false> {
private:
    template <typename From1, typename To1, typename = decltype(_NEFORCE declvoid<To1>(_NEFORCE declval<From1>()))>
    static true_type __test(int);
 
    template <typename, typename>
    static false_type __test(...);
 
public:
    using type = decltype(__test<From, To>(0));
};
NEFORCE_END_INNER__
#endif

template <typename From, typename To>
struct is_convertible :
#if defined(NEFORCE_COMPILER_MSVC)
        bool_constant<__is_convertible_to(From, To)> {
};
#elif defined(NEFORCE_COMPILER_CLANG)
        bool_constant<__is_convertible(From, To)> {
};
#else
        inner::__is_convertible_helper<From, To>::type {
};
#endif
 
#ifdef NEFORCE_STANDARD_14
template <typename From, typename To>
NEFORCE_INLINE17 constexpr bool is_convertible_v = is_convertible<From, To>::value;
#endif
 
#if defined(NEFORCE_STANDARD_20) || defined(NEXUSFORCE_ENABLE_DOXYGEN)
template <typename From, typename To>
concept convertible_to = is_convertible_v<From, To> && requires { static_cast<To>(_NEFORCE declval<From>()); };
#endif // NEFORCE_STANDARD_20
 

template <typename ToElement, typename FromElement>
using is_array_convertible = is_convertible<FromElement (*)[], ToElement (*)[]>;
 
#ifdef NEFORCE_STANDARD_14
template <typename ToElement, typename FromElement>
NEFORCE_INLINE17 constexpr bool is_array_convertible_v = is_array_convertible<ToElement, FromElement>::value;
#endif
 

template <typename From, typename To, bool IsConvertible = is_convertible<From, To>::value,
          bool IsVoid = is_void<To>::value>
struct is_nothrow_convertible : bool_constant<noexcept(_NEFORCE declcopy<To>(_NEFORCE declval<From>()))> {};

template <typename From, typename To, bool IsVoid>
struct is_nothrow_convertible<From, To, false, IsVoid> : false_type {};
 
template <typename From, typename To>
struct is_nothrow_convertible<From, To, true, true> : true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename From, typename To>
NEFORCE_INLINE17 constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<From, To>::value;
#endif
 

template <typename Iterator, typename Ptr, bool IsPtr = is_pointer<remove_cvref_t<Iterator>>::value>
struct is_nothrow_arrow : bool_constant<is_nothrow_convertible<Iterator, Ptr>::value> {};

template <typename Iterator, typename Ptr>
struct is_nothrow_arrow<Iterator, Ptr, false>
: bool_constant<noexcept(_NEFORCE declcopy<Ptr>(_NEFORCE declval<Iterator>().operator->()))> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename Iterator, typename Ptr>
NEFORCE_INLINE17 constexpr bool is_nothrow_arrow_v = is_nothrow_arrow<Iterator, Ptr>::value;
#endif
 // ConvertibleChecks


NEFORCE_BEGIN_INNER__
template <size_t>
struct __sign_byte_aux;
 
template <>
struct __sign_byte_aux<1> {
    template <typename>
    using signed_t = signed char;
    template <typename>
    using unsigned_t = unsigned char;
};
template <>
struct __sign_byte_aux<2> {
    template <typename>
    using signed_t = signed short;
    template <typename>
    using unsigned_t = unsigned short;
};
template <>
struct __sign_byte_aux<4> {
#ifdef NEFORCE_PLATFORM_WINDOWS
    template <typename T>
    using signed_t = conditional_t<is_same_v<T, signed long> || is_same_v<T, unsigned long>, signed long, signed int>;
 
    template <typename T>
    using unsigned_t =
            conditional_t<is_same_v<T, signed long> || is_same_v<T, unsigned long>, unsigned long, unsigned int>;
#elif defined(NEFORCE_PLATFORM_LINUX)
    template <typename>
    using signed_t = signed int;
    template <typename>
    using unsigned_t = unsigned int;
#endif
};
template <>
struct __sign_byte_aux<8> {
#ifdef NEFORCE_PLATFORM_WINDOWS
    template <typename>
    using signed_t = signed long long;
    template <typename>
    using unsigned_t = unsigned long long;
#elif defined(NEFORCE_PLATFORM_LINUX)
    template <typename T>
    using signed_t = conditional_t<is_same<T, signed long>::value || is_same<T, unsigned long>::value, signed long,
                                   signed long long>;
 
    template <typename T>
    using unsigned_t = conditional_t<is_same<T, signed long>::value || is_same<T, unsigned long>::value, unsigned long,
                                     unsigned long long>;
#endif
};
 
template <typename T>
using __set_signed_byte = typename __sign_byte_aux<sizeof(T)>::template signed_t<T>;
template <typename T>
using __set_unsigned_byte = typename __sign_byte_aux<sizeof(T)>::template unsigned_t<T>;
 
template <typename T>
struct __set_sign {
    static_assert(is_integral_like<T>::value && !is_boolean<T>::value,
                  "make signed only support non-bool && integral-like types");
 
    using signed_type = copy_cv_t<T, __set_signed_byte<T>>;
    using unsigned_type = copy_cv_t<T, __set_unsigned_byte<T>>;
};
NEFORCE_END_INNER__

template <typename T>
struct make_signed {
    using type = typename inner::__set_sign<T>::signed_type;
};

template <typename T>
using make_signed_t = typename make_signed<T>::type;

template <typename T>
struct make_unsigned {
    using type = typename inner::__set_sign<T>::unsigned_type;
};

template <typename T>
using make_unsigned_t = typename make_unsigned<T>::type;
 

NEFORCE_BEGIN_INNER__
template <size_t Size, bool IsSigned>
struct __make_integer_impl;
 
template <size_t Size>
struct __make_integer_impl<Size, true> {
    using type = typename __sign_byte_aux<Size>::template signed_t<int>;
};
 
template <size_t Size>
struct __make_integer_impl<Size, false> {
    using type = typename __sign_byte_aux<Size>::template unsigned_t<int>;
};
NEFORCE_END_INNER__

template <size_t Size, bool IsSigned = true>
struct make_integer {
    using type = typename inner::__make_integer_impl<Size, IsSigned>::type;
};

template <size_t Size, bool IsSigned = true>
using make_integer_t = typename make_integer<Size, IsSigned>::type;
 

template <size_t... Values>
struct max_value;

template <size_t Value>
struct max_value<Value> : integral_constant<size_t, Value> {};
 
template <size_t First, size_t Second, size_t... Rest>
struct max_value<First, Second, Rest...> : max_value<(First > Second ? First : Second), Rest...> {};
 
#ifdef NEFORCE_STANDARD_14
template <size_t... Values>
NEFORCE_INLINE17 constexpr size_t max_value_v = max_value<Values...>::value;
#endif
 // SignManipulation


template <typename T>
struct alignment_of : integral_constant<size_t, alignof(T)> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
constexpr size_t alignment_of_v = alignment_of<T>::value;
#endif
 

template <size_t Len, size_t Align = alignof(_NEFORCE max_align_t)>
struct aligned_storage {
    static_assert((Align & (Align - 1)) == 0, "Alignment must be power of two");

    struct alignas(Align) type {
        byte_t data[Len]; 
    };
};

template <size_t Len, size_t Align = alignof(_NEFORCE max_align_t)>
using aligned_storage_t = typename aligned_storage<Len, Align>::type;
 

template <size_t Len, typename... Types>
struct aligned_union {
private:
    static constexpr size_t required_alignment = max_value<alignof(Types)...>::value;
    static constexpr size_t required_size = max_value<sizeof(Types)...>::value;
    static constexpr size_t storage_size = (Len > required_size) ? Len : required_size;
 
    static_assert((required_alignment & (required_alignment - 1)) == 0, "Alignment must be power of two");
 
public:
    static constexpr size_t alignment_value = required_alignment;
    static constexpr size_t size_value = storage_size;

    struct alignas(alignment_value) type {
        byte_t data[storage_size]; 
    };

    template <typename T>
    static constexpr bool is_storable() noexcept {
        return is_trivially_copyable<T>::value && sizeof(T) <= storage_size && alignof(T) <= alignment_value;
    }
};

template <size_t Len, typename... Types>
using aligned_union_t = typename aligned_union<Len, Types...>::type;
 
#ifdef NEFORCE_STANDARD_14
template <size_t Len, typename... Types>
constexpr size_t aligned_union_v = aligned_union<Len, Types...>::align_value;
#endif
 // Alignment


template <typename T>
struct decay {
private:
    using remove_ref_t = remove_reference_t<T>;
    using check_func_t =
            conditional_t<is_function<remove_ref_t>::value, add_pointer_t<remove_ref_t>, remove_cv_t<remove_ref_t>>;
 
public:
    using type =
            conditional_t<is_array<remove_ref_t>::value, add_pointer_t<remove_extent_t<remove_ref_t>>, check_func_t>;
};

template <typename T>
using decay_t = typename decay<T>::type;
 

NEFORCE_BEGIN_INNER__
template <typename Default, typename, template <typename...> class, typename...>
struct __detector {
    using value_t = false_type;
    using type = Default;
};
template <typename Default, template <typename...> class Op, typename... Args>
struct __detector<Default, void_t<Op<Args...>>, Op, Args...> {
    using value_t = true_type;
    using type = Op<Args...>;
};
NEFORCE_END_INNER__

template <typename Default, template <typename...> class Op, typename... Args>
using detected_or = inner::__detector<Default, void, Op, Args...>;

template <typename Default, template <typename...> class Op, typename... Args>
using detected_or_t = typename detected_or<Default, Op, Args...>::type;
 

template <typename T1, typename T2>
using common_ternary_operator_t = decltype(true ? _NEFORCE declval<T1>() : _NEFORCE declval<T2>());
 

NEFORCE_BEGIN_INNER__
template <typename, typename, typename = void>
struct __oper_decay_aux {};
template <typename T1, typename T2>
struct __oper_decay_aux<T1, T2, void_t<common_ternary_operator_t<decay_t<T1>, decay_t<T2>>>> {
    using type = decay_t<common_ternary_operator_t<decay_t<T1>, decay_t<T2>>>;
};
NEFORCE_END_INNER__

template <typename... Types>
struct common_type;

template <typename... Types>
using common_type_t = typename common_type<Types...>::type;

template <>
struct common_type<> {};
 
template <typename T1>
struct common_type<T1> : common_type<T1, T1> {};
 
template <typename T1, typename T2>
struct common_type<T1, T2> : inner::__oper_decay_aux<T1, T2> {};
 
template <typename T1, typename T2, typename... Rest>
struct common_type<T1, T2, Rest...> : common_type<common_type_t<T1, T2>, Rest...> {};
 
 
#ifdef NEFORCE_STANDARD_20

template <typename... Types>
struct common_reference;

template <typename... Types>
using common_reference_t = typename common_reference<Types...>::type;

 
template <>
struct common_reference<> {};
 
template <typename T>
struct common_reference<T> {
    using type = T;
};
 
 
NEFORCE_BEGIN_INNER__
 
template <typename T1, typename T2>
struct __common_reference_base_aux : common_type<T1, T2> {};
 
template <typename T1, typename T2>
    requires requires { typename _NEFORCE common_ternary_operator_t<T1, T2>; }
struct __common_reference_base_aux<T1, T2> {
    using type = _NEFORCE common_ternary_operator_t<T1, T2>;
};
 
template <typename, typename, template <typename> typename, template <typename> typename>
struct __basic_common_reference {};
 
template <typename T1>
struct __add_qualifier_aux {
    template <typename T2>
    using apply_t = copy_ref_t<T1, copy_cv_t<T1, T2>>;
};
 
template <typename T1, typename T2>
using qualifier_extract = typename __basic_common_reference<remove_cvref_t<T1>, remove_cvref_t<T2>,
                                                            __add_qualifier_aux<T1>::template apply_t,
                                                            __add_qualifier_aux<T2>::template apply_t>::type;
 
template <typename T1, typename T2>
struct __common_ref_qualify_aux : __common_reference_base_aux<T1, T2> {};
 
template <typename T1, typename T2>
    requires requires { typename qualifier_extract<T1, T2>; }
struct __common_ref_qualify_aux<T1, T2> {
    using type = qualifier_extract<T1, T2>;
};
 
template <typename T1, typename T2>
struct __common_reference_ptr_aux : __common_ref_qualify_aux<T1, T2> {};
 
template <typename T1, typename T2>
    requires is_lvalue_reference_v<common_ternary_operator_t<copy_cv_t<T1, T2>&, copy_cv_t<T2, T1>&>>
using __common_lvalue_aux = common_ternary_operator_t<copy_cv_t<T1, T2>&, copy_cv_t<T2, T1>&>;
 
template <typename, typename>
struct __common_reference_aux {};
 
template <typename T1, typename T2>
    requires requires { typename __common_lvalue_aux<T1, T2>; }
struct __common_reference_aux<T1&, T2&> {
    using type = __common_lvalue_aux<T1, T2>;
};
 
template <typename T1, typename T2>
    requires is_convertible_v<T1&&, __common_lvalue_aux<const T1, T2>>
struct __common_reference_aux<T1&&, T2&> {
    using type = __common_lvalue_aux<const T1, T2>;
};
 
template <typename T1, typename T2>
    requires is_convertible_v<T2&&, __common_lvalue_aux<const T2, T1>>
struct __common_reference_aux<T1&, T2&&> {
    using type = __common_lvalue_aux<const T2, T1>;
};
 
template <typename T1, typename T2>
using __common_rvalue_aux = remove_reference_t<__common_lvalue_aux<T1, T2>>&&;
 
template <typename T1, typename T2>
    requires is_convertible_v<T1&&, __common_rvalue_aux<T1, T2>> && is_convertible_v<T2&&, __common_rvalue_aux<T1, T2>>
struct __common_reference_aux<T1&&, T2&&> {
    using type = __common_rvalue_aux<T1, T2>;
};
 
template <typename T1, typename T2>
using __common_reference_aux_t = typename __common_reference_aux<T1, T2>::type;
 
template <typename T1, typename T2>
    requires is_convertible_v<add_pointer_t<T1>, add_pointer_t<__common_reference_aux_t<T1, T2>>> &&
             is_convertible_v<add_pointer_t<T2>, add_pointer_t<__common_reference_aux_t<T1, T2>>>
struct __common_reference_ptr_aux<T1, T2> {
    using type = __common_reference_aux_t<T1, T2>;
};
 
NEFORCE_END_INNER__
 
 
template <typename T1, typename T2>
struct common_reference<T1, T2> : inner::__common_reference_ptr_aux<T1, T2> {};
 
template <typename T1, typename T2, typename T3, typename... Rest>
struct common_reference<T1, T2, T3, Rest...> {};
 
template <typename T1, typename T2, typename T3, typename... Rest>
    requires requires { typename common_reference_t<T1, T2>; }
struct common_reference<T1, T2, T3, Rest...> : common_reference<common_reference_t<T1, T2>, T3, Rest...> {};

#endif
 

template <typename T, template <typename...> class Template>
struct is_specialization : false_type {};

template <template <typename...> class Template, typename... Args>
struct is_specialization<Template<Args...>, Template> : true_type {};
 
#ifdef NEFORCE_STANDARD_17
template <typename T, template <typename...> class Template>
NEFORCE_INLINE17 constexpr bool is_specialization_v = is_specialization<T, Template>::value;
#else
template <typename T, template <typename...> class Template>
constexpr bool is_specialization_v() {
    return is_specialization<T, Template>::value;
}
#endif
 // TypeAttributeOperations

 
template <typename>
struct is_swappable;
 
template <typename>
struct is_nothrow_swappable;
 

template <typename T>
NEFORCE_CONSTEXPR14 enable_if_t<is_move_constructible_v<T> && is_move_assignable_v<T>>
swap(T& lhs, T& rhs) noexcept(is_nothrow_move_constructible_v<T> && is_nothrow_move_assignable_v<T>);

template <typename T, size_t Size>
NEFORCE_CONSTEXPR14 enable_if_t<is_swappable<T>::value> swap(T (&lhs)[Size],
                                                             T (&rhs)[Size]) noexcept(is_nothrow_swappable<T>::value);

void swap() = delete;

template <typename T, typename U = T>
NEFORCE_CONSTEXPR14 T exchange(T& val, U&& new_val) noexcept(is_nothrow_move_constructible_v<T> &&
                                                             is_nothrow_assignable_v<T&, U>);
 

template <typename T1, typename T2, typename Dummy = void>
struct is_swappable_from : false_type {};

template <typename T1, typename T2>
struct is_swappable_from<T1, T2, void_t<decltype(_NEFORCE swap(_NEFORCE declval<T1>(), _NEFORCE declval<T2>()))>>
: true_type {};
 

template <typename T1, typename T2>
struct is_swappable_with : bool_constant<conjunction<is_swappable_from<T1, T2>, is_swappable_from<T2, T1>>::value> {};
 

template <typename T>
struct is_swappable : bool_constant<is_swappable_with<add_lvalue_reference_t<T>, add_lvalue_reference_t<T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_swappable_v = is_swappable<T>::value;
#endif
 

template <typename T1, typename T2>
struct is_nothrow_swappable_from
: bool_constant<noexcept(_NEFORCE swap(_NEFORCE declval<T1>(), _NEFORCE declval<T2>())) &&
                noexcept(_NEFORCE swap(_NEFORCE declval<T2>(), _NEFORCE declval<T1>()))> {};
 

template <typename T1, typename T2>
struct is_nothrow_swappable_with
: bool_constant<conjunction<is_swappable_with<T1, T2>, is_nothrow_swappable_from<T1, T2>>::value> {};
 

template <typename T>
struct is_nothrow_swappable
: bool_constant<is_nothrow_swappable_with<add_lvalue_reference_t<T>, add_lvalue_reference_t<T>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<T>::value;
#endif
 

template <typename T, typename Dummy = void>
struct is_ADL_swappable : false_type {};

template <typename T>
struct is_ADL_swappable<T, void_t<decltype(swap(_NEFORCE declval<T&>(), _NEFORCE declval<T&>()))>> : true_type {};
 

template <typename T>
struct is_trivially_swappable
: bool_constant<conjunction<is_trivially_destructible<T>, is_trivially_move_constructible<T>,
                            is_trivially_move_assignable<T>, negation<is_ADL_swappable<T>>>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_trivially_swappable_v = is_trivially_swappable<T>::value;
#endif

 
template <typename T>
NEFORCE_CONSTEXPR14 enable_if_t<is_move_constructible_v<T> && is_move_assignable_v<T>>
swap(T& lhs, T& rhs) noexcept(is_nothrow_move_constructible_v<T> && is_nothrow_move_assignable_v<T>) {
    T tmp = _NEFORCE move(lhs);
    lhs = _NEFORCE move(rhs);
    rhs = _NEFORCE move(tmp);
    return;
}
 
template <typename T, size_t Size>
NEFORCE_CONSTEXPR14 enable_if_t<is_swappable<T>::value> swap(T (&lhs)[Size],
                                                             T (&rhs)[Size]) noexcept(is_nothrow_swappable<T>::value) {
    if (&lhs == &rhs) {
        return;
    }
    T* first1 = lhs;
    T* last1 = first1 + Size;
    T* first2 = rhs;
    for (; first1 != last1; ++first1, ++first2) {
        _NEFORCE swap(*first1, *first2);
    }
    return;
}
 
template <typename T, typename U>
NEFORCE_CONSTEXPR14 T exchange(T& val, U&& new_val) noexcept(is_nothrow_move_constructible_v<T> &&
                                                             is_nothrow_assignable_v<T&, U>) {
    T old_val = _NEFORCE move(val);
    val = _NEFORCE forward<U>(new_val);
    return old_val;
}

 // SwapUtility

 
#ifdef NEFORCE_STANDARD_20
template <typename T>
concept is_pair_v = requires(T p) {
    typename T::first_type;
    typename T::second_type;
    p.first;
    p.second;
};
#endif // NEFORCE_STANDARD_20
 

template <typename Alloc, typename Dummy = void>
struct is_allocator : false_type {};

template <typename Alloc>
struct is_allocator<Alloc, void_t<typename Alloc::value_type, decltype(declval<Alloc&>().allocate(size_t{}))>>
: true_type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename Alloc>
NEFORCE_INLINE17 constexpr bool is_allocator_v = is_allocator<Alloc>::value;
#endif
 

NEFORCE_BEGIN_INNER__
template <typename T>
struct __has_valid_begin_end {
private:
    template <typename U>
    static auto __test(int)
            -> decltype(declval<U>().begin(), declval<U>().end(),
                        is_same<decltype(declval<U>().begin()), decltype(declval<U>().end())>(), true_type{});
 
    template <typename U>
    static false_type __test(...);
 
public:
    static constexpr bool value = decltype(__test<T>(0))::value;
};
NEFORCE_END_INNER__
 

template <typename Iterator>
struct is_incrementible {
private:
    template <typename U>
    static auto __test(int) -> decltype(++declval<U&>(), true_type{});
 
    template <typename U>
    static false_type __test(...);
 
public:
    static constexpr bool value = decltype(__test<Iterator>(0))::value;
};
 
#ifdef NEFORCE_STANDARD_14
template <typename Iterator>
NEFORCE_INLINE17 constexpr bool is_incrementible_v = is_incrementible<Iterator>::value;
#endif
 

template <typename Iterator>
struct is_decrementible {
private:
    template <typename U>
    static auto __test(int) -> decltype(--declval<U&>(), true_type{});
 
    template <typename U>
    static false_type __test(...);
 
public:
    static constexpr bool value = decltype(__test<Iterator>(0))::value;
};
 
#ifdef NEFORCE_STANDARD_14
template <typename Iterator>
NEFORCE_INLINE17 constexpr bool is_decrementible_v = is_decrementible<Iterator>::value;
#endif
 

template <typename Container>
struct is_iterable : bool_constant<inner::__has_valid_begin_end<Container>::value &&
                                   is_incrementible<decltype(declval<Container>().begin())>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool is_iterable_v = is_iterable<T>::value;
#endif
 

NEFORCE_BEGIN_INNER__
template <typename T>
struct __has_first_and_second {
private:
    template <typename U>
    static auto __test(int) -> decltype(declval<U>().first, declval<U>().second, true_type{});
 
    template <typename U>
    static false_type __test(...);
 
public:
    static constexpr bool value = decltype(__test<T>(0))::value;
};
NEFORCE_END_INNER__

template <typename Map>
struct is_maplike
: bool_constant<is_iterable<Map>::value &&
                inner::__has_first_and_second<decltype(*declval<decltype(declval<Map>().begin())>())>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename Map>
NEFORCE_INLINE17 constexpr bool is_maplike_v = is_maplike<Map>::value;
#endif
 

NEFORCE_BEGIN_INNER__
template <typename Alloc, typename T, typename... Args>
struct __has_construct_impl {
private:
    template <typename Alloc1, typename = decltype(_NEFORCE declval<Alloc1*>()->construct(_NEFORCE declval<T*>(),
                                                                                          _NEFORCE declval<Args>()...))>
    static true_type __test(int);
 
    template <typename>
    static false_type __test(...);
 
public:
    using type = decltype(__test<Alloc>(0));
};
NEFORCE_END_INNER__

template <typename Alloc, typename T, typename... Args>
struct has_construct : inner::__has_construct_impl<Alloc, T, Args...>::type {};
 
#ifdef NEFORCE_STANDARD_14
template <typename Alloc, typename T, typename... Args>
NEFORCE_INLINE17 constexpr bool has_construct_v = has_construct<Alloc, T, Args...>::value;
#endif
 

NEFORCE_BEGIN_INNER__
template <typename T>
struct __has_base_impl {
private:
    template <typename U>
    static auto __test(int) -> decltype(_NEFORCE declval<const U>().base(), true_type{});
 
    template <typename U>
    static false_type __test(...);
 
public:
    static constexpr bool value = decltype(__test<T>(0))::value;
};
NEFORCE_END_INNER__

template <typename T>
struct has_base : bool_constant<inner::__has_base_impl<T>::value> {};
 
#ifdef NEFORCE_STANDARD_14
template <typename T>
NEFORCE_INLINE17 constexpr bool has_base_v = has_base<T>::value;
#endif
 // TypeActionCheck


template <typename T>
NEFORCE_ALWAYS_INLINE constexpr T initialize() noexcept(is_nothrow_default_constructible<T>::value) {
    static_assert(is_default_constructible<T>::value, "T must be default constructible");
    return T();
}
 
#define __NEFORCE_INITIALIZE_BASIC_FUNCTION(OPT)                \
    template <>                                                 \
    NEFORCE_ALWAYS_INLINE constexpr OPT initialize() noexcept { \
        return static_cast<OPT>(0);                             \
    }
 
NEFORCE_MACRO_RANGE_ARITHMETIC(__NEFORCE_INITIALIZE_BASIC_FUNCTION)
#undef __NEFORCE_INITIALIZE_BASIC_FUNCTION
 // TypeInitializeFunction
 // TypeTraits
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_TYPEINFO_TYPE_TRAITS_HPP__