TypeTraitsMacros.h

 
#pragma once
 
#include <type_traits>
 
#define RFK_GENERATE_IMPLEMENTS_METHOD_TRAITS(MethodName)                                                                               \
template<typename Class, typename T>    struct implements_##MethodName {};                                                              \
template <typename Class, typename Ret, typename... Args>                                                                               \
struct implements_##MethodName<Class, Ret(Args...)>                                                                                     \
{                                                                                                                                       \
    private:                                                                                                                            \
        template<typename T>                                                                                                            \
        static constexpr auto check(T*) -> typename std::is_same<decltype(std::declval<T>().MethodName(std::declval<Args>()...)), Ret>; \
                                                                                                                                        \
        template<typename>                                                                                                              \
        static constexpr std::false_type check(...);                                                                                    \
                                                                                                                                        \
    public:                                                                                                                             \
        static constexpr bool value = decltype(check<Class>(nullptr))::value;                                                           \
}
 
#define RFK_GENERATE_IMPLEMENTS_STATIC_METHOD_TRAITS(MethodName)                                                            \
template<typename Class, typename T>    struct implements_static_##MethodName {};                                           \
template <typename Class, typename Ret, typename... Args>                                                                   \
struct implements_static_##MethodName<Class, Ret(Args...)>                                                                  \
{                                                                                                                           \
    private:                                                                                                                \
        template<typename T>                                                                                                \
        static constexpr auto check(T*) -> typename std::is_same<decltype(T::MethodName(std::declval<Args>()...)), Ret>;    \
                                                                                                                            \
        template<typename>                                                                                                  \
        static constexpr std::false_type check(...);                                                                        \
                                                                                                                            \
    public:                                                                                                                 \
        static constexpr bool value = decltype(check<Class>(nullptr))::value;                                               \
}
 
#define RFK_GENERATE_IS_CALLABLE_METHOD_TRAITS(MethodName)                                                                                      \
template<typename Class, typename T>    struct isCallable_##MethodName {};                                                                      \
template <typename Class, typename Ret, typename... Args>                                                                                       \
struct isCallable_##MethodName<Class, Ret(Args...)>                                                                                             \
{                                                                                                                                               \
    private:                                                                                                                                    \
        template<typename T>                                                                                                                    \
        static constexpr auto check(T*) -> typename std::is_convertible<decltype(std::declval<T>().MethodName(std::declval<Args>()...)), Ret>;  \
                                                                                                                                                \
        template<typename>                                                                                                                      \
        static constexpr std::false_type check(...);                                                                                            \
                                                                                                                                                \
    public:                                                                                                                                     \
        static constexpr bool value = decltype(check<Class>(nullptr))::value;                                                                   \
}
 
#define RFK_GENERATE_IS_CALLABLE_STATIC_METHOD_TRAITS(MethodName)                                                               \
template<typename Class, typename T>    struct isCallable_static_##MethodName {};                                               \
template <typename Class, typename Ret, typename... Args>                                                                       \
struct isCallable_static_##MethodName<Class, Ret(Args...)>                                                                      \
{                                                                                                                               \
    private:                                                                                                                    \
        template<typename T>                                                                                                    \
        static constexpr auto check(T*) -> typename std::is_convertible<decltype(T::MethodName(std::declval<Args>()...)), Ret>; \
                                                                                                                                \
        template<typename>                                                                                                      \
        static constexpr std::false_type check(...);                                                                            \
                                                                                                                                \
    public:                                                                                                                     \
        static constexpr bool value = decltype(check<Class>(nullptr))::value;                                                   \
}
 
#define RFK_GENERATE_IMPLEMENTS_TEMPLATE1_METHOD_TRAITS(MethodName)                                                                                             \
template<typename Class, typename TemplateType1, typename T>    struct implements_template1_##MethodName {};                                                    \
template <typename Class, typename TemplateType1, typename Ret, typename... Args>                                                                               \
struct implements_template1_##MethodName<Class, TemplateType1, Ret(Args...)>                                                                                    \
{                                                                                                                                                               \
    private:                                                                                                                                                    \
        template<typename T>                                                                                                                                    \
        static constexpr auto check(T*) -> typename std::is_same<decltype(std::declval<T>().template MethodName<TemplateType1>(std::declval<Args>()...)), Ret>; \
                                                                                                                                                                \
        template<typename>                                                                                                                                      \
        static constexpr std::false_type check(...);                                                                                                            \
                                                                                                                                                                \
    public:                                                                                                                                                     \
        static constexpr bool value = decltype(check<Class>(nullptr))::value;                                                                                   \
}
 
#define RFK_GENERATE_HAS_FIELD_TRAITS(fieldName)                                                                                                \
template <typename Class, typename FieldType>                                                                                                   \
struct hasField_##fieldName                                                                                                                     \
{                                                                                                                                               \
    private:                                                                                                                                    \
        template <typename T>                                                                                                                   \
        static constexpr auto check(T*) -> typename std::is_same<std::remove_reference_t<decltype(std::declval<T>().fieldName)>, FieldType>;    \
                                                                                                                                                \
        template <typename>                                                                                                                     \
        static constexpr std::false_type check(...);                                                                                            \
                                                                                                                                                \
    public:                                                                                                                                     \
        static constexpr bool value = decltype(check<Class>(nullptr))::value;                                                                   \
}