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 "CeresEngine/Foundation/TypeTraits.hpp"
#include "CeresEngine/Foundation/MPL/TypeList.hpp"
#include "CeresEngine/Foundation/MPL/TypeListOps.hpp"
 
#include <type_traits>
 
namespace CeresEngine {
 
    namespace internal {
 
        template<typename F> struct function_traits_helper : function_traits_helper<decltype(&F::operator())> {};
 
        template<typename R, typename... Args> struct function_traits_helper<R (*)(Args...)> {
            using class_type = void;
 
            using is_const = std::false_type;
            using is_volatile = std::false_type;
            using is_lrefthis = std::false_type;
            using is_rrefthis = std::false_type;
            using is_noexcept = std::false_type;
 
            using result_type = R;
            using args = MPL::TypeList<Args...>;
            static constexpr std::size_t arity = MPL::size<args>();
            template<std::size_t i> using arg = MPL::Nth<i, args>;
 
            using base_signature = R(Args...);
            using uniformSignature = R(Args...);
        };
 
        template<typename R, typename... Args> struct function_traits_helper<R (*)(Args...) noexcept> : function_traits_helper<R (*)(Args...)> {
            using is_noexcept = std::true_type;
            using base_signature = R(Args...) noexcept;
            using uniformSignature = R(Args...) noexcept;
        };
 
        template<typename C, typename R, typename... Args> struct function_traits_helper<R (C::*)(Args...)> : function_traits_helper<R (*)(Args...)> {
            using class_type = C;
            using uniformSignature = R(C&, Args...);
        };
 
        template<typename C, typename R, typename... Args>
        struct function_traits_helper<R (C::*)(Args...) noexcept> : function_traits_helper<R (*)(Args...) noexcept> {
            using class_type = C;
            using uniformSignature = R(C&, Args...) noexcept;
        };
 
        template<typename C, typename R, typename... Args> struct function_traits_helper<R (C::*)(Args...)&> : function_traits_helper<R (C::*)(Args...)> {
            using is_lrefthis = std::true_type;
        };
 
        template<typename C, typename R, typename... Args> struct function_traits_helper<R (C::*)(Args...) &&> : function_traits_helper<R (C::*)(Args...)> {
            using is_rrefthis = std::true_type;
            using uniformSignature = R(C&&, Args...);
        };
 
        template<typename C, typename R, typename... Args> struct function_traits_helper<R (C::*)(Args...) const> : function_traits_helper<R (*)(Args...)> {
            using class_type = C;
            using is_const = std::true_type;
            using uniformSignature = R(C const&, Args...);
        };
 
        template<typename C, typename R, typename... Args>
        struct function_traits_helper<R (C::*)(Args...) const noexcept> : function_traits_helper<R (*)(Args...) noexcept> {
            using class_type = C;
            using is_const = std::true_type;
            using uniformSignature = R(C const&, Args...) noexcept;
        };
 
        template<typename C, typename R, typename... Args>
        struct function_traits_helper<R (C::*)(Args...) const&> : function_traits_helper<R (C::*)(Args...) const> {
            using is_lrefthis = std::true_type;
        };
 
        template<typename C, typename R, typename... Args>
        struct function_traits_helper<R (C::*)(Args...) const&&> : function_traits_helper<R (C::*)(Args...) const> {
            using is_rrefthis = std::true_type;
            using uniformSignature = R(C const&&, Args...);
        };
 
        template<typename C, typename R, typename... Args> struct function_traits_helper<R (C::*)(Args...) volatile> : function_traits_helper<R (*)(Args...)> {
            using class_type = C;
            using is_volatile = std::true_type;
            using uniformSignature = R(volatile C&, Args...);
        };
 
        template<typename C, typename R, typename... Args>
        struct function_traits_helper<R (C::*)(Args...) volatile&> : function_traits_helper<R (C::*)(Args...) volatile> {
            using is_lrefthis = std::true_type;
        };
 
        template<typename C, typename R, typename... Args>
        struct function_traits_helper<R (C::*)(Args...) volatile&&> : function_traits_helper<R (C::*)(Args...) volatile> {
            using is_rrefthis = std::true_type;
            using uniformSignature = R(volatile C&&, Args...);
        };
 
        template<typename C, typename R, typename... Args>
        struct function_traits_helper<R (C::*)(Args...) const volatile> : function_traits_helper<R (*)(Args...)> {
            using class_type = C;
            using is_const = std::true_type;
            using is_volatile = std::true_type;
            using uniformSignature = R(C const volatile&, Args...);
        };
 
        template<typename C, typename R, typename... Args>
        struct function_traits_helper<R (C::*)(Args...) const volatile&> : function_traits_helper<R (C::*)(Args...) const volatile> {
            using is_lrefthis = std::true_type;
        };
 
        template<typename C, typename R, typename... Args>
        struct function_traits_helper<R (C::*)(Args...) const volatile&&> : function_traits_helper<R (C::*)(Args...) const volatile> {
            using is_rrefthis = std::true_type;
            using uniformSignature = R(C const volatile&&, Args...);
        };
 
        template<typename F> struct function_traits_helper<std::function<F>> : function_traits_helper<F> {};
 
    } // namespace internal
 
    template<typename F> struct function_traits : internal::function_traits_helper<std::decay_t<F>> {};
 
    // Factory
    template<typename F> using function_type = std::function<typename function_traits<F>::base_signature>;
    template<typename F> inline function_type<F> make_function(F&& f) { return function_type<F>{std::forward<F>(f)}; }
 
    // ---------------------------------------------------------------------------------------------
 
    namespace mpl {
 
        // identity
        template<typename T> struct identity {
            using type = T;
        };
 
        // index sequence
        template<std::size_t... Ints> struct index_sequence {
            using size = std::integral_constant<std::size_t, sizeof...(Ints)>;
        };
 
        template<std::size_t N, std::size_t... Ints> struct make_index_sequence : make_index_sequence<N - 1, N - 1, Ints...> {};
        template<std::size_t... Ints> struct make_index_sequence<0, Ints...> : identity<index_sequence<Ints...>> {};
        template<typename... Args> struct index_sequence_for : make_index_sequence<sizeof...(Args)> {};
        template<typename... Args> struct index_sequence_for<MPL::TypeList<Args...>> : index_sequence_for<Args...> {};
        template<typename... Args> struct index_sequence_for<std::tuple<Args...>> : index_sequence_for<Args...> {};
        template<typename... Args> using index_sequence_for_t = typename index_sequence_for<Args...>::type;
 
    } // namespace mpl
 
    // ---------------------------------------------------------------------------------------------
 
    namespace internal {
        template<class T, class = decltype(std::declval<T>() == std::declval<T>())> std::true_type HasOperatorEqualsTest(const T&);
        std::false_type HasOperatorEqualsTest(...);
    } // namespace internal
 
    template<class T> static constexpr bool HasOperatorEquals = decltype(internal::HasOperatorEqualsTest(std::declval<T>()))::value;
 
} // namespace CeresEngine