Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include "Utilities/TMPL.hpp"
       7              : 
       8              : namespace tt {
       9              : /// \cond
      10              : namespace detail {
      11              : template <typename T>
      12              : struct function_info_impl;
      13              : 
      14              : template <typename Ret, typename... Args>
      15              : struct function_info_impl<Ret(Args...)> {
      16              :   using return_type = Ret;
      17              :   using argument_types = tmpl::list<Args...>;
      18              :   using class_type = void;
      19              : };
      20              : 
      21              : template <typename Ret, typename... Args>
      22              : struct function_info_impl<Ret(Args...) noexcept> {
      23              :   using return_type = Ret;
      24              :   using argument_types = tmpl::list<Args...>;
      25              :   using class_type = void;
      26              : };
      27              : 
      28              : #define FUNCTION_INFO_IMPL_FUNCTION_PTR(MODIFIERS, NOEXCEPT_STATUS)        \
      29              :   template <typename Ret,                                                  \
      30              :             typename... Args> /* NOLINTNEXTLINE(misc-macro-parentheses) */ \
      31              :   struct function_info_impl<Ret (*MODIFIERS)(Args...) NOEXCEPT_STATUS> {   \
      32              :     using return_type = Ret;                                               \
      33              :     using argument_types = tmpl::list<Args...>;                            \
      34              :     using class_type = void;                                               \
      35              :   }
      36              : 
      37              : FUNCTION_INFO_IMPL_FUNCTION_PTR(, );
      38              : FUNCTION_INFO_IMPL_FUNCTION_PTR(, noexcept);
      39              : FUNCTION_INFO_IMPL_FUNCTION_PTR(const, );
      40              : FUNCTION_INFO_IMPL_FUNCTION_PTR(const, noexcept);
      41              : FUNCTION_INFO_IMPL_FUNCTION_PTR(volatile, );
      42              : FUNCTION_INFO_IMPL_FUNCTION_PTR(volatile, noexcept);
      43              : FUNCTION_INFO_IMPL_FUNCTION_PTR(const volatile, );
      44              : FUNCTION_INFO_IMPL_FUNCTION_PTR(const volatile, noexcept);
      45              : #undef FUNCTION_INFO_IMPL_FUNCTION_PTR
      46              : 
      47              : #define FUNCTION_INFO_IMPL_CLASS(MODIFIERS)                                \
      48              :   template <typename Ret, typename Class,                                  \
      49              :             typename... Args> /* NOLINTNEXTLINE(misc-macro-parentheses) */ \
      50              :   struct function_info_impl<Ret (Class::*)(Args...) MODIFIERS> {           \
      51              :     using return_type = Ret;                                               \
      52              :     using argument_types = tmpl::list<Args...>;                            \
      53              :     using class_type = Class;                                              \
      54              :   }
      55              : 
      56              : FUNCTION_INFO_IMPL_CLASS();
      57              : FUNCTION_INFO_IMPL_CLASS(const);
      58              : FUNCTION_INFO_IMPL_CLASS(noexcept);
      59              : FUNCTION_INFO_IMPL_CLASS(volatile);
      60              : FUNCTION_INFO_IMPL_CLASS(const noexcept);
      61              : FUNCTION_INFO_IMPL_CLASS(const volatile);
      62              : FUNCTION_INFO_IMPL_CLASS(const volatile noexcept);
      63              : FUNCTION_INFO_IMPL_CLASS(volatile noexcept);
      64              : #undef FUNCTION_INFO_IMPL_CLASS
      65              : }  // namespace detail
      66              : /// \endcond
      67              : 
      68              : /*!
      69              :  * \ingroup TypeTraitsGroup
      70              :  * \brief Returns a struct that contains the return type, argument types, and
      71              :  * the class type if the `F` is a non-static member function
      72              :  *
      73              :  * The return class has member type aliases:
      74              :  * - `return_type` The return type of the function
      75              :  * - `argument_types` A `tmpl::list` of the arguments types of the function
      76              :  * - `class_type` The type of the class if the function is a non-static member
      77              :  * function, otherwise `void`
      78              :  *
      79              :  * \note For static member variables the class will be `void` because they are
      80              :  * effectively free functions.
      81              :  */
      82              : template <typename F>
      83            1 : using function_info = detail::function_info_impl<F>;
      84              : }  // namespace tt