type_traits.hxx

#pragma once
 
#include <concepts>
#include <optional>
#include <string>
#include <type_traits>
#include <utility>
#include <variant>
 
namespace StormByte {
    // Implementation detail: type traits for internal use only
    namespace {
        template<typename T>
        struct is_string : std::bool_constant<std::is_same_v<T, std::string> || std::is_same_v<T, std::wstring>> {};
 
        template<typename T, typename _ = void>
        struct is_container : std::false_type {};
 
        template<typename T>
        struct is_container<T, std::void_t<decltype(std::declval<T>().begin()), decltype(std::declval<T>().end()), typename T::value_type>> 
            : std::bool_constant<!is_string<std::decay_t<T>>::value> {};
 
        template<typename T, typename _ = void>
        struct is_optional : std::false_type {};
 
        template<typename T>
        struct is_optional<T, std::void_t<typename T::value_type>> 
            : std::is_same<T, std::optional<typename T::value_type>> {};
 
        template<typename T, typename _ = void>
        struct is_pair : std::false_type {};
 
        template<typename T>
        struct is_pair<T, std::void_t<
            decltype(std::declval<T>().first), 
            decltype(std::declval<T>().second)
        >> : std::true_type {};
 
        template<typename T>
        struct is_variant : std::false_type {};
 
        template<typename... Ts>
        struct is_variant<std::variant<Ts...>> : std::true_type {};
 
        template<typename VariantT, typename U, std::size_t... I>
        constexpr bool variant_has_type_impl(std::index_sequence<I...>) noexcept {
            return ((std::is_same_v<std::remove_cvref_t<U>, std::remove_cvref_t<std::variant_alternative_t<I, VariantT>>>) || ...);
        }
 
        template<typename VariantT, typename U>
        struct variant_has_type : std::bool_constant<
            variant_has_type_impl<VariantT, U>(std::make_index_sequence<std::variant_size_v<VariantT>>())
        > {};
 
        template<typename U>
        constexpr U swap_endian(U val) noexcept {
            union {
                U value;
                unsigned char bytes[sizeof(U)];
            } src, dest;
 
            src.value = val;
            for (std::size_t i = 0; i < sizeof(U); ++i) {
                dest.bytes[i] = src.bytes[sizeof(U) - 1 - i];
            }
            return dest.value;
        }
    }
 
    namespace Type {
        template<typename T>
        concept String = is_string<T>::value;
 
        template<typename T>
        concept Container = is_container<T>::value;
 
        template<typename C>
        concept HasPushBack = Container<C> && requires(C& c, typename C::value_type const& v) {
            c.push_back(v);
        };
 
        template<typename C>
        concept HasPushFront = Container<C> && requires(C& c, typename C::value_type const& v) {
            c.push_front(v);
        };
 
        template<typename C>
        concept HasInsert = Container<C> && requires(C& c, typename C::value_type const& v) {
            c.insert(v);
        };
 
        template<typename C, typename U>
        concept HasSubscript = Container<C> && requires(C& c, U const& u) {
            { c[u] };
        };
 
        template<typename C>
        concept HasKeyType = Container<C> && requires { typename C::key_type; };
 
        template<typename C>
        concept HasMappedType = Container<C> && requires { typename C::mapped_type; };
 
        template<typename T>
        concept Optional = is_optional<T>::value;
 
        template<typename T>
        concept Pair = is_pair<T>::value;
 
        template<typename T>
        concept Reference = std::is_reference_v<T>;
 
        template<typename E>
        concept Enum = std::is_enum_v<std::remove_cv_t<E>>;
 
        template<typename E>
        concept UnsignedEnum =
            Enum<E> &&
            std::is_unsigned_v<std::underlying_type_t<std::remove_cv_t<E>>>;
 
        template<typename E>
        concept ScopedEnum = std::is_scoped_enum_v<E>;
 
        template<typename E>
        requires Enum<E>
        using UnderlyingType = std::underlying_type_t<std::remove_cv_t<E>>;
 
        template<typename E>
        requires Enum<E>
        constexpr UnderlyingType<E> ToUnderlying(E e) noexcept {
            return static_cast<UnderlyingType<E>>(e);
        }
 
        template<typename T>
        concept Pointer = std::is_pointer_v<T>;
 
        template<typename T>
        concept Integral = std::is_integral_v<T>;
 
        template<typename T>
        concept FloatingPoint = std::is_floating_point_v<T>;
 
        template<typename T>
        concept Arithmetic = std::is_arithmetic_v<T>;
 
        template<typename T>
        concept Signed = std::is_signed_v<T>;
 
        template<typename T>
        concept Unsigned = std::is_unsigned_v<T>;
 
        template<typename T>
        concept Const = std::is_const_v<T>;
 
        template<typename T>
        concept Class = std::is_class_v<T>;
 
        template<typename T>
        concept Variant = is_variant<std::remove_cvref_t<T>>::value;
 
        template<typename T, typename U>
        concept VariantHasType = Variant<T> && variant_has_type<std::remove_cvref_t<T>, U>::value;
 
        template<typename T>
        concept TriviallyCopyable = std::is_trivially_copyable_v<T>;
 
        template<typename T>
        concept TriviallyDestructible = std::is_trivially_destructible_v<T>;
 
        template<typename T>
        concept DefaultConstructible = std::is_default_constructible_v<T>;
 
        template<typename T>
        concept CopyConstructible = std::is_copy_constructible_v<T>;
 
        template<typename T>
        concept MoveConstructible = std::is_move_constructible_v<T>;
 
        template<typename F, typename... Args>
        concept Callable = std::is_invocable_v<F, Args...>;
 
        template<typename T, typename U>
        concept SameAs = std::is_same_v<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;
 
        template<typename From, typename To>
        concept ConvertibleTo = std::is_convertible_v<From, To>;
    }
}