SFINAE.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 "TypeTraits.hpp"
 
#define CE_SFINAE_HAS_TYPE(NAME)                                                     \
    template<typename, typename = void> struct has_type_##NAME : std::false_type {}; \
    template<typename T> struct has_type_##NAME<T, std::void_t<typename T::NAME>> : std::true_type {};
 
#define CE_SFINAE_HAS_METHOD(NAME)                                                                                                                            \
    namespace internal {                                                                                                                                      \
        template<typename T, bool is_class = std::is_class<T>::value, typename = void> struct has_method_##NAME##_helper : std::false_type {};                \
                                                                                                                                                              \
        template<typename T> struct has_method_##NAME##_helper<T, true, std::void_t<decltype(&T::NAME)>> : has_method_##NAME##_helper<decltype(&T::NAME)> {}; \
                                                                                                                                                              \
        template<typename Signature> struct has_method_##NAME##_helper<Signature, false> {                                                                    \
            static_assert(std::is_member_function_pointer<Signature>::value, "Not a member function pointer");                                                \
            using T = typename function_traits<Signature>::class_type;                                                                                        \
            static_assert(!std::is_void<T>::value, "Void class type");                                                                                        \
                                                                                                                                                              \
            template<typename C, typename = std::void_t<decltype(static_cast<Signature>(&C::NAME))>> static auto check(int) -> std::true_type;                \
            template<typename> static auto check(...) -> std::false_type;                                                                                     \
                                                                                                                                                              \
            using type = decltype(check<T>(0));                                                                                                               \
        };                                                                                                                                                    \
    }                                                                                                                                                         \
    template<typename Signature> struct has_method_##NAME : internal::has_method_##NAME##_helper<Signature>::type {};
 
#define CE_SFINAE_CAN_CALL_METHOD(NAME)                                                                                                              \
    namespace internal {                                                                                                                             \
        template<typename T, typename... Args> using result_of_call_method_##NAME = decltype(std::declval<T>().NAME(std::declval<Args>()...));       \
    }                                                                                                                                                \
    template<typename T, typename Signature, typename = void> struct can_call_method_##NAME : std::false_type {};                                    \
    template<typename T, typename... Args>                                                                                                           \
    struct can_call_method_##NAME<T, void(Args...), std::void_t<internal::result_of_call_method_##NAME<T, Args...>>> : std::true_type {};            \
    template<typename T, typename R, typename... Args>                                                                                               \
    struct can_call_method_##NAME<T, R(Args...),                                                                                                     \
        typename std::enable_if<!std::is_void<R>::value && std::is_convertible<internal::result_of_call_method_##NAME<T, Args...>, R>::value>::type> \
            : std::true_type {};