type_traits.hpp

Go to the documentation of this file.

// Copyright Take Vos 2019-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "architecture.hpp"
#include <cstdint>
#include <type_traits>
#include <string>
#include <string_view>
#include <memory>
#include <variant>
 
namespace hi::inline v1 {
 
// clang-format off
 
template<typename T> struct is_numeric_signed_integral : std::false_type {}; 
template<> struct is_numeric_signed_integral<signed char> : std::true_type {};
template<> struct is_numeric_signed_integral<signed short> : std::true_type {};
template<> struct is_numeric_signed_integral<signed int> : std::true_type {};
template<> struct is_numeric_signed_integral<signed long> : std::true_type {};
template<> struct is_numeric_signed_integral<signed long long> : std::true_type {};
 
template<typename T>
inline constexpr bool is_numeric_signed_integral_v = is_numeric_signed_integral<T>::value;
 
template<typename T> struct is_numeric_unsigned_integral : std::false_type {}; 
template<> struct is_numeric_unsigned_integral<unsigned int> : std::true_type {};
template<> struct is_numeric_unsigned_integral<unsigned char> : std::true_type {};
template<> struct is_numeric_unsigned_integral<unsigned short> : std::true_type {};
template<> struct is_numeric_unsigned_integral<unsigned long> : std::true_type {};
template<> struct is_numeric_unsigned_integral<unsigned long long> : std::true_type {};
 
template<typename T>
inline constexpr bool is_numeric_unsigned_integral_v = is_numeric_unsigned_integral<T>::value;
 
template<typename T> struct is_numeric_integral : std::false_type {}; 
template<> struct is_numeric_integral<unsigned int> : std::true_type {};
template<> struct is_numeric_integral<unsigned char> : std::true_type {};
template<> struct is_numeric_integral<unsigned short> : std::true_type {};
template<> struct is_numeric_integral<unsigned long> : std::true_type {};
template<> struct is_numeric_integral<unsigned long long> : std::true_type {};
template<> struct is_numeric_integral<signed char> : std::true_type {};
template<> struct is_numeric_integral<signed short> : std::true_type {};
template<> struct is_numeric_integral<signed int> : std::true_type {};
template<> struct is_numeric_integral<signed long> : std::true_type {};
template<> struct is_numeric_integral<signed long long> : std::true_type {};
 
template<typename T> inline constexpr bool is_numeric_integral_v = is_numeric_integral<T>::value;
 
template<typename T> struct is_numeric : std::false_type {}; 
template<> struct is_numeric<unsigned char> : std::true_type {};
template<> struct is_numeric<unsigned short> : std::true_type {};
template<> struct is_numeric<unsigned int> : std::true_type {};
template<> struct is_numeric<unsigned long> : std::true_type {};
template<> struct is_numeric<unsigned long long> : std::true_type {};
template<> struct is_numeric<signed char> : std::true_type {};
template<> struct is_numeric<signed short> : std::true_type {};
template<> struct is_numeric<signed int> : std::true_type {};
template<> struct is_numeric<signed long> : std::true_type {};
template<> struct is_numeric<signed long long> : std::true_type {};
template<> struct is_numeric<float> : std::true_type {};
template<> struct is_numeric<double> : std::true_type {};
template<> struct is_numeric<long double> : std::true_type {};
 
template<typename T> inline constexpr bool is_numeric_v = is_numeric<T>::value;
 
template<typename T> struct is_character : std::false_type {}; 
template<> struct is_character<char> : std::true_type {};
template<> struct is_character<wchar_t> : std::true_type {};
template<> struct is_character<char8_t> : std::true_type {};
template<> struct is_character<char16_t> : std::true_type {};
template<> struct is_character<char32_t> : std::true_type {};
 
template<typename T> inline constexpr bool is_character_v = is_character<T>::value;
 
template<typename T> struct make_string { };
template<> struct make_string<char> { using type = std::string; };
template<> struct make_string<wchar_t> { using type = std::wstring; };
template<> struct make_string<char8_t> { using type = std::u8string; };
template<> struct make_string<char16_t> { using type = std::u16string; };
template<> struct make_string<char32_t> { using type = std::u32string; };
 
template<typename T> using make_string_t = typename make_string<T>::type;
 
template<typename T> struct make_string_view { using type = void; };
template<> struct make_string_view<char> { using type = std::string_view; };
template<> struct make_string_view<wchar_t> { using type = std::wstring_view; };
template<> struct make_string_view<char8_t> { using type = std::u8string_view; };
template<> struct make_string_view<char16_t> { using type = std::u16string_view; };
template<> struct make_string_view<char32_t> { using type = std::u32string_view; };
 
template<typename T>
using make_string_view_t = typename make_string_view<T>::type;
 
template<typename T, typename U>
struct make_promote {
    using type = decltype(static_cast<T>(0) + static_cast<U>(0));
};
 
template<typename T, typename U>
using make_promote_t = typename make_promote<T,U>::type;
 
template<typename T, typename Ei=void>
struct make_intmax {
    using type = uintmax_t;
};
 
template<std::unsigned_integral T>
struct make_intmax<T> {
    using type = uintmax_t;
};
 
template<std::signed_integral T>
struct make_intmax<T> {
    using type = intmax_t;
};
 
template<typename T>
using make_intmax_t = typename make_intmax<T>::type;
 
template<std::size_t N> struct has_intxx : public std::false_type {};
 
template<std::size_t N> struct has_uintxx : public std::false_type {};
 
template<std::size_t N> struct has_floatxx : public std::false_type {};
 
template<std::size_t N> struct make_intxx {};
 
template<std::size_t N> struct make_uintxx {};
 
template<std::size_t N> struct make_floatxx {};
 
#if (HI_COMPILER == HI_CC_CLANG || HI_COMPILER == HI_CC_GCC) && (HI_PROCESSOR == HI_CPU_X64)
template<> struct has_intxx<128> : public std::true_type {};
template<> struct has_uintxx<128> : public std::true_type {};
template<> struct make_intxx<128> { using type = __int128; };
template<> struct make_uintxx<128> { using type = unsigned __int128; };
#endif
template<> struct has_intxx<64> : public std::true_type {};
template<> struct has_uintxx<64> : public std::true_type {};
template<> struct has_floatxx<64> : public std::true_type {};
template<> struct make_intxx<64> { using type = int64_t; };
template<> struct make_uintxx<64> { using type = uint64_t; };
template<> struct make_floatxx<64> { using type = double; };
template<> struct has_intxx<32> : public std::true_type {};
template<> struct has_uintxx<32> : public std::true_type {};
template<> struct has_floatxx<32> : public std::true_type {};
template<> struct make_intxx<32> { using type = int32_t; };
template<> struct make_uintxx<32> { using type = uint32_t; };
template<> struct make_floatxx<32> { using type = float; };
template<> struct has_intxx<16> : public std::true_type {};
template<> struct has_uintxx<16> : public std::true_type {};
template<> struct make_intxx<16> { using type = int16_t; };
template<> struct make_uintxx<16> { using type = uint16_t; };
template<> struct has_intxx<8> : public std::true_type {};
template<> struct has_uintxx<8> : public std::true_type {};
template<> struct make_intxx<8> { using type = int8_t; };
template<> struct make_uintxx<8> { using type = uint8_t; };
 
template<std::size_t N> constexpr bool has_intxx_v = has_intxx<N>::value;
template<std::size_t N> constexpr bool has_uintxx_v = has_uintxx<N>::value;
template<std::size_t N> constexpr bool has_floatxx_v = has_floatxx<N>::value;
template<std::size_t N> using make_intxx_t = typename make_intxx<N>::type;
template<std::size_t N> using make_uintxx_t = typename make_uintxx<N>::type;
template<std::size_t N> using make_floatxx_t = typename make_floatxx<N>::type;
 
template<typename L, typename... R>
struct common_integer;
 
template<std::integral T>
struct common_integer<T,T> {
    using type = T;
};
 
template<std::unsigned_integral L, std::unsigned_integral R>
struct common_integer<L,R> {
    using type = std::conditional_t<(sizeof(L) > sizeof(R)), L, R>;
};
 
template<std::signed_integral L, std::signed_integral R>
struct common_integer<L,R> {
    using type = std::conditional_t<(sizeof(L) > sizeof(R)), L, R>;
};
 
template<std::unsigned_integral L, std::signed_integral R>
struct common_integer<L,R> {
    using _left_type =
        std::conditional_t<(sizeof(L) < sizeof(short)), short,
        std::conditional_t<(sizeof(L) < sizeof(int)), int,
        std::conditional_t<(sizeof(L) < sizeof(long)), long, long long>>>;
        
    using type = common_integer<_left_type, R>::type;
};
 
template<std::signed_integral L, std::unsigned_integral R>
struct common_integer<L,R> {
    using type = common_integer<R, L>::type;
};
 
template<std::integral L, std::integral M, std::integral... R>
struct common_integer<L, M, R...> {
    using type = common_integer<L, typename common_integer<M, R...>::type>::type;
};
 
template<std::integral L, std::integral... R>
using common_integer_t = common_integer<L, R...>::type;
 
 
template<typename To, typename From, typename Ei=void>
struct copy_cv {};
 
template<typename To, typename From> requires(not std::is_const_v<From> and not std::is_volatile_v<From>)
struct copy_cv<To,From> {
    using type = std::remove_cv_t<To>;
};
 
template<typename To, typename From> requires(not std::is_const_v<From> and std::is_volatile_v<From>)
struct copy_cv<To,From> {
    using type = std::remove_cv_t<To> volatile;
};
 
template<typename To, typename From> requires(std::is_const_v<From> and not std::is_volatile_v<From>)
struct copy_cv<To,From> {
    using type = std::remove_cv_t<To> const;
};
 
template<typename To, typename From> requires(std::is_const_v<From> and std::is_volatile_v<From>)
struct copy_cv<To,From> {
    using type = std::remove_cv_t<To> const volatile;
};
 
template<typename To, typename From>
using copy_cv_t = typename copy_cv<To,From>::type;
 
template <typename T> struct has_value_type 
{
    template <typename C> static std::true_type test(typename C::value_type *);
    template <typename> static std::false_type test(...);
 
    static const bool value = std::is_same_v<decltype(test<T>(nullptr)), std::true_type>;
};
 
template<typename T>
inline constexpr bool has_value_type_v = has_value_type<T>::value;
 
template <typename T> struct has_add_callback 
{
    template <typename C> static std::true_type test(decltype(&C::add_callback) func_ptr);
    template <typename> static std::false_type test(...);
 
    static const bool value = std::is_same_v<decltype(test<T>(nullptr)), std::true_type>;
};
 
template<typename T>
inline constexpr bool has_add_callback_v = has_add_callback<T>::value;
 
template<typename BaseType, typename DerivedType>
struct is_decayed_base_of : public std::is_base_of<std::decay_t<BaseType>,std::decay_t<DerivedType>> {};
 
template<typename BaseType, typename DerivedType>
constexpr bool is_decayed_base_of_v = is_decayed_base_of<BaseType,DerivedType>::value;
 
template<typename DerivedType, typename BaseType>
struct is_derived_from : public std::is_base_of<BaseType,DerivedType> {};
 
template<typename DerivedType, typename BaseType>
constexpr bool is_derived_from_v = is_derived_from<DerivedType,BaseType>::value;
 
template<typename DerivedType, typename BaseType>
struct is_decayed_derived_from : public is_decayed_base_of<BaseType,DerivedType> {};
 
template<typename DerivedType, typename BaseType>
constexpr bool is_decayed_derived_from_v = is_decayed_derived_from<DerivedType,BaseType>::value;
 
template<typename Context, typename Expected>
constexpr bool is_different_v = not std::is_same_v<std::decay_t<Context>,std::decay_t<Expected>>;
 
template<typename T>
struct is_atomic : public std::false_type {};
 
template<typename T>
struct is_atomic<std::atomic<T>> : public std::true_type {};
 
template<typename T>
constexpr bool is_atomic_v = is_atomic<T>::value;
 
template<typename First, typename Second>
struct use_first {
    using type = First;
};
 
template<typename First, typename Second>
using use_first_t = use_first<First,Second>;
 
template<typename T>
struct smart_pointer_traits {
    constexpr static bool value = false;
 
    using type = void;
};
 
template<typename T> struct smart_pointer_traits<std::shared_ptr<T>> {constexpr static bool value = true; using type = T;};
template<typename T> struct smart_pointer_traits<std::weak_ptr<T>> {constexpr static bool value = true; using type = T;};
template<typename T> struct smart_pointer_traits<std::unique_ptr<T>> {constexpr static bool value = true; using type = T;};
template<typename T> struct smart_pointer_traits<T *> {constexpr static bool value = true; using type = T;};
 
#define hi_call_method(object, method, ...) \
    [&]() { \
        if constexpr (smart_pointer_traits<std::decay_t<decltype(object)>>::value) { \
            return object->method(__VA_ARGS__); \
        } else { \
            return object.method(__VA_ARGS__); \
        } \
    }()
 
template<typename Out, typename In>
constexpr bool type_in_range_v = std::numeric_limits<Out>::digits >= std::numeric_limits<In>::digits and
    (std::numeric_limits<Out>::is_signed == std::numeric_limits<In>::is_signed or std::numeric_limits<Out>::is_signed);
 
template<typename Context, typename Expected, typename... OtherExpected>
struct is_forward_of;
 
template<typename Context, typename Expected, typename FirstOtherExpected, typename... OtherExpected>
struct is_forward_of<Context, Expected, FirstOtherExpected, OtherExpected...> : std::conditional_t<
        is_forward_of<Context, Expected>::value or
        (is_forward_of<Context, FirstOtherExpected>::value or ... or is_forward_of<Context, OtherExpected>::value),
        std::true_type,
        std::false_type> {};
 
template<typename Context, typename Expected>
struct is_forward_of<Context, Expected> :
    std::conditional_t<
        std::is_same_v<std::decay_t<Context>, Expected> or std::is_base_of_v<Expected, std::decay_t<Context>>,
        std::true_type,
        std::false_type> {
    static_assert(not std::is_reference_v<Expected>, "Template argument Expected must be a non-reference type.");
};
 
template<typename Context, typename Expected>
struct is_forward_of<Context, std::shared_ptr<Expected>> :
    std::conditional_t<
        std::is_convertible_v<Context, std::shared_ptr<Expected>>,
        std::true_type,
        std::false_type> {};
 
template<typename Context, typename Expected>
struct is_forward_of<Context, std::weak_ptr<Expected>> :
    std::conditional_t<
        std::is_convertible_v<Context, std::weak_ptr<Expected>>,
        std::true_type,
        std::false_type> {};
 
template<typename Context, typename Expected>
struct is_forward_of<Context, std::unique_ptr<Expected>> :
    std::conditional_t<
        std::is_convertible_v<Context, std::unique_ptr<Expected>>,
        std::true_type,
        std::false_type> {};
 
template<typename Context, typename Expected>
struct is_forward_of<Context, Expected *> :
    std::conditional_t<
        std::is_convertible_v<Context, Expected *>,
        std::true_type,
        std::false_type> {};
 
template<typename Context, typename Result, typename... Args>
struct is_forward_of<Context, Result(Args...)> :
    std::conditional_t<std::is_invocable_r_v<Result, Context, Args...>, std::true_type, std::false_type> {
};
 
template<typename Context, typename Expected, typename... OtherExpected>
constexpr bool is_forward_of_v = is_forward_of<Context, Expected, OtherExpected...>::value;
 
template<typename Context>
struct forward_copy_or_ref {
    using type = std::conditional_t<std::is_rvalue_reference_v<Context>, std::decay_t<Context>, std::decay_t<Context> const &>;
};
 
template<typename Context>
using forward_copy_or_ref_t = forward_copy_or_ref<Context>::type;
 
 
template<typename T>
struct variant_decay {
    using type = std::decay_t<T>;
};
 
template<>
struct variant_decay<void> {
    using type = std::monostate;
};
 
template<typename T>
using variant_decay_t = variant_decay<T>::type;
 
template<typename T>
struct selector;
 
 
template<typename T>
struct type_documentation;
 
 
 
template<class... Ts>
struct overloaded : Ts... {
    // Makes the call operator of each lambda available directly to the `overloaded` type. 
    using Ts::operator()...;
 
    // The implicit constructor is all that is needed to initialize each lambda. 
};
 
} // namespace hi::inline v1