Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <type_traits>
       7              : 
       8              : /// @{
       9              : /*!
      10              :  * \ingroup TypeTraitsGroup
      11              :  * \brief Generate a type trait to check if a class has a member function that
      12              :  * can be invoked with arguments of type `TArgs...`
      13              :  *
      14              :  * The usage of the type trait is identical to the usage of the
      15              :  * `tt::is_callable` type trait. The name of the type trait is
      16              :  * `is_METHOD_NAME_callable` and is not placed in
      17              :  * the `tt` namespace. To avoid collisions it is highly recommended that type
      18              :  * traits generated with this macro are generated into `_detail` namespaces.
      19              :  * This will reduce redefinition compilation errors.
      20              :  *
      21              :  * Note that variable templates with `_r` and `_t` suffixes that follow the
      22              :  * standard library's naming convention are also generated. To generate
      23              :  * corresponding `_v` metafunctions, call `CREATE_IS_CALLABLE` first and then
      24              :  * `CREATE_IS_CALLABLE_V` and/or `CREATE_IS_CALLABLE_R_V`.
      25              :  *
      26              :  * \example
      27              :  * \snippet Test_CreateIsCallable.cpp CREATE_IS_CALLABLE_EXAMPLE
      28              :  *
      29              :  * \see tt::is_callable
      30              :  */
      31            1 : #define CREATE_IS_CALLABLE(METHOD_NAME)                                        \
      32              :   struct AnyReturnType##METHOD_NAME {};                                        \
      33              :                                                                                \
      34              :   template <typename ReturnType, typename TT, typename... TArgs>               \
      35              :   class is_##METHOD_NAME##_callable_r {                                        \
      36              :    private:                                                                    \
      37              :     struct NotCallable {};                                                     \
      38              :     template <typename T, typename... Args>                                    \
      39              :     static auto test_callable(int)                                             \
      40              :         -> decltype(std::declval<T>().METHOD_NAME(std::declval<Args>()...));   \
      41              :     template <typename, typename...>                                           \
      42              :     static auto test_callable(...) -> NotCallable;                             \
      43              :                                                                                \
      44              :    public:                                                                     \
      45              :     static constexpr bool value =                                              \
      46              :         (std::is_same_v<ReturnType, AnyReturnType##METHOD_NAME> and            \
      47              :          not std::is_same_v<decltype(test_callable<TT, TArgs...>(0)),          \
      48              :                             NotCallable>) or                                   \
      49              :         std::is_same_v<decltype(test_callable<TT, TArgs...>(0)), ReturnType>;  \
      50              :     using type = std::integral_constant<bool, value>;                          \
      51              :   };                                                                           \
      52              :   template <typename ReturnType, typename T, typename... Args>                 \
      53              :   using is_##METHOD_NAME##_callable_r_t =                                      \
      54              :       typename is_##METHOD_NAME##_callable_r<ReturnType, T, Args...>::type;    \
      55              :   template <typename TT, typename... TArgs>                                    \
      56              :   using is_##METHOD_NAME##_callable =                                          \
      57              :       is_##METHOD_NAME##_callable_r<AnyReturnType##METHOD_NAME, TT, TArgs...>; \
      58              :   template <typename TT, typename... TArgs>                                    \
      59              :   using is_##METHOD_NAME##_callable_t =                                        \
      60              :       is_##METHOD_NAME##_callable_r_t<AnyReturnType##METHOD_NAME, TT,          \
      61              :                                       TArgs...>;
      62              : 
      63              : // Separate macros to avoid compiler warnings about unused variables
      64            1 : #define CREATE_IS_CALLABLE_R_V(METHOD_NAME)                    \
      65              :   template <typename ReturnType, typename T, typename... Args> \
      66              :   constexpr bool is_##METHOD_NAME##_callable_r_v =             \
      67              :       is_##METHOD_NAME##_callable_r<ReturnType, T, Args...>::value;
      68            1 : #define CREATE_IS_CALLABLE_V(METHOD_NAME)        \
      69              :   template <typename T, typename... Args>        \
      70              :   constexpr bool is_##METHOD_NAME##_callable_v = \
      71              :       is_##METHOD_NAME##_callable<T, Args...>::value;
      72              : /// @}