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             : namespace tt {
       9             : /// @{
      10             : /// \ingroup TypeTraitsGroup
      11             : /// \brief Check if a type `T` is callable, i.e. `T(Args...)` is evaluable.
      12             : ///
      13             : /// \details
      14             : /// Inherits from std::true_type if `TT` has the call operator, operator()
      15             : /// defined with arguments `TArgs...`, otherwise inherits from std::false_type.
      16             : ///
      17             : /// \usage
      18             : /// For any type `TT` and types `TArgs_i`,
      19             : /// \code
      20             : /// using result = tt::is_callable<TT, TArgs_0, TArgs_1, TArgs_2>;
      21             : /// \endcode
      22             : ///
      23             : /// \metareturns
      24             : /// std::bool_constant
      25             : ///
      26             : /// \semantics
      27             : /// If the type `TT` defines operator() with arguments `TArgs...`, then
      28             : /// \code
      29             : /// typename result::type = std::true_type;
      30             : /// \endcode
      31             : /// otherwise
      32             : /// \code
      33             : /// typename result::type = std::false_type;
      34             : /// \endcode
      35             : ///
      36             : /// \example
      37             : /// \snippet Test_IsCallable.cpp is_callable_example
      38             : /// \see std::is_callable
      39             : /// \tparam TT the class to check
      40             : /// \tparam TArgs the args passed to operator()
      41             : template <typename TT, typename... TArgs>
      42           1 : class is_callable {
      43             :   // The reason we have private before public here is that we have static member
      44             :   // functions and since this is meant to be a super lightweight helper class
      45             :   // it's better to break convention than increase code size.
      46             :  private:
      47             :   /// \cond
      48             :   // We pass an int here to disambiguate the two possible templates and have the
      49             :   // compiler prefer the first one. If it cannot be used because there's no
      50             :   // call operator, then it uses the second one.
      51             :   template <typename T, typename... Args>
      52             :   static auto test_callable(int)
      53             :       -> decltype(std::declval<T>()(std::declval<Args>()...), std::true_type());
      54             : 
      55             :   template <typename, typename...>
      56             :   static auto test_callable(...) -> std::false_type;
      57             :   /// \endcond
      58             : 
      59             :  public:
      60             :   /// `true` if callable, `false` otherwise
      61           1 :   static constexpr bool value = decltype(test_callable<TT, TArgs...>(0))::value;
      62             :   /// `std::true_type` if callable, `std::false_type` otherwise
      63           1 :   using type = std::integral_constant<bool, value>;
      64             : };
      65             : /// \see is_callable
      66             : template <typename T, typename... Args>
      67           1 : constexpr bool is_callable_v = is_callable<T, Args...>::value;
      68             : 
      69             : /// \see is_callable
      70             : template <typename T, typename... Args>
      71           1 : using is_callable_t = typename is_callable<T, Args...>::type;
      72             : /// @}
      73             : }  // namespace tt