TypeTraits.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include <functional>
#include <type_traits>
 
namespace CeresEngine {
 
    namespace impl {
        template<typename Type, typename... Arguments>
        struct is_explicitly_constructible_t : std::bool_constant<std::is_constructible<Type, Arguments...>::value> {};
 
        template<typename Type, typename Argument, typename... Arguments>
        struct is_explicitly_constructible_t<Type, Argument, Arguments...>
                : std::bool_constant<std::is_constructible<Type, Argument, Arguments...>::value && !std::is_convertible<Argument, Type>::value> {};
    } // namespace impl
 
    template<typename Type, typename... Arguments> constexpr bool is_explicitly_constructible = impl::is_explicitly_constructible_t<Type, Arguments...>::value;
 
    namespace impl {
        template<typename Type, typename... Arguments>
        struct is_implicitly_constructible_t : std::bool_constant<std::is_constructible<Type, Arguments...>::value> {};
 
        template<typename Type, typename Argument, typename... Arguments>
        struct is_implicitly_constructible_t<Type, Argument, Arguments...>
                : std::bool_constant<std::is_constructible<Type, Argument, Arguments...>::value && std::is_convertible<Argument, Type>::value> {};
    } // namespace impl
 
    template<typename Type, typename... Arguments> constexpr bool is_implicitly_constructible = impl::is_implicitly_constructible_t<Type, Arguments...>::value;
 
    // Non-capturing lambdas have a very interesting property : they can convert to an adequate function pointer,
    // but they can also do so explicitly when you apply unary operator+ to them
 
    template<typename T, typename = void> struct is_capturing_lambda : std::true_type {};
    template<typename T> struct is_capturing_lambda<T, std::void_t<decltype(+std::declval<T>())>> : std::false_type {};
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> struct size_of_t : std::integral_constant<std::size_t, sizeof(T)> {};
    template<typename R, typename... Args> struct size_of_t<R (*)(Args...)> : std::integral_constant<std::size_t, sizeof(void*)> {};
    template<> struct size_of_t<void> : std::integral_constant<std::size_t, 0> {};
    template<typename T> constexpr auto size_of = size_of_t<T>::value;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T, bool = std::is_pointer_v<T>> struct pointer_arity_t;
    template<typename T> constexpr auto pointer_arity = pointer_arity_t<T>::value;
 
    template<typename T> struct pointer_arity_t<T, false> : std::integral_constant<std::size_t, 0> {};
    template<typename T> struct pointer_arity_t<T, true> : std::integral_constant<std::size_t, pointer_arity<std::remove_pointer_t<T>> + 1> {};
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> struct array_length_t : std::integral_constant<std::size_t, 1> {};
    template<typename T> constexpr auto array_length = array_length_t<T>::value;
    template<typename T, std::size_t N> struct array_length_t<T[N]> : std::integral_constant<std::size_t, N * array_length<T>> {};
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T, bool = std::is_reference_v<T>, bool = std::is_pointer_v<T>, bool = std::is_array_v<T>> struct remove_all_cv_t;
 
    template<typename T> using remove_all_cv = typename remove_all_cv_t<T>::type;
 
    template<typename T> struct remove_all_cv_t<T, false, false, false> { using type = std::remove_cv_t<T>; };
 
    template<typename T> struct remove_all_cv_t<T, true, false, false> {
        constexpr static auto lref = std::is_lvalue_reference_v<T>;
        using U = remove_all_cv<std::remove_reference_t<T>>;
        using type = std::conditional_t<lref, std::add_lvalue_reference_t<U>, std::add_rvalue_reference_t<U>>;
    };
 
    template<typename T> struct remove_all_cv_t<T, false, true, false> {
        using U = remove_all_cv<std::remove_pointer_t<T>>;
        using type = std::add_pointer_t<U>;
    };
 
    template<typename T> struct remove_all_cv_t<T, false, false, true> {
        constexpr static auto extent = std::extent_v<T>;
        using U = remove_all_cv<std::remove_extent_t<T>>;
        using type = U[extent];
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> using full_decay = remove_all_cv<std::decay_t<T>>;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T, typename... Args> struct is_converting_constructor_t : std::false_type {};
    template<typename T, typename Arg>
    struct is_converting_constructor_t<T, Arg>
            : std::conditional_t<!std::is_same_v<T, full_decay<Arg>> && std::is_convertible_v<Arg, T>, std::true_type, std::false_type> {};
    template<typename T, typename... Args> constexpr auto is_converting_constructor = is_converting_constructor_t<T, Args...>::value;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> constexpr auto is_lvalue_const_reference = std::is_lvalue_reference_v<T>&& std::is_const_v<std::remove_reference_t<T>>;
 
} // namespace CeresEngine