robot/include/rttr/detail/misc/function_traits.h

/************************************************************************************
*                                                                                   *
*   Copyright (c) 2014 - 2018 Axel Menzel <info@rttr.org>                           *
*                                                                                   *
*   This file is part of RTTR (Run Time Type Reflection)                            *
*   License: MIT License                                                            *
*                                                                                   *
*   Permission is hereby granted, free of charge, to any person obtaining           *
*   a copy of this software and associated documentation files (the "Software"),    *
*   to deal in the Software without restriction, including without limitation       *
*   the rights to use, copy, modify, merge, publish, distribute, sublicense,        *
*   and/or sell copies of the Software, and to permit persons to whom the           *
*   Software is furnished to do so, subject to the following conditions:            *
*                                                                                   *
*   The above copyright notice and this permission notice shall be included in      *
*   all copies or substantial portions of the Software.                             *
*                                                                                   *
*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR      *
*   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,        *
*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE     *
*   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER          *
*   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,   *
*   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE   *
*   SOFTWARE.                                                                       *
*                                                                                   *
*************************************************************************************/

#ifndef RTTR_FUNCTION_TRAITS_H_
#define RTTR_FUNCTION_TRAITS_H_

#include "rttr/detail/base/core_prerequisites.h"
#include "rttr/detail/misc/misc_type_traits.h"
#include "rttr/detail/misc/std_type_traits.h"

#include <type_traits>
#include <functional>
#include <tuple>

namespace rttr
{
namespace detail
{

    /////////////////////////////////////////////////////////////////////////////////////

    template<typename T>
    struct is_function_ptr : std::integral_constant<bool, std::is_pointer<T>::value &&
                                                          std::is_function<::rttr::detail::remove_pointer_t<T>>::value>
    {
    };

    /////////////////////////////////////////////////////////////////////////////////////
    // snippet provided by K-ballo
    struct helper
    {
        void operator()(...);
    };

    template <typename T>
    struct helper_composed: T, helper
    {};

    template <void (helper::*) (...)>
    struct member_function_holder
    {};

    template <typename T, typename Ambiguous = member_function_holder<&helper::operator()> >
    struct is_functor_impl : std::true_type
    {};

    template <typename T>
    struct is_functor_impl<T, member_function_holder<&helper_composed<T>::operator()> > : std::false_type
    {};

    /*!
     * \brief Returns true whether the given type T is a functor.
     *        i.e. func(...); That can be free function, lambdas or function objects.
     */
    template <typename T>
    struct is_functor : conditional_t<std::is_class<T>::value,
                                      is_functor_impl<T>,
                                      std::false_type>
    {};

    template<typename R, typename... Args>
    struct is_functor<R (*)(Args...)> : std::true_type {};

    template<typename R, typename... Args>
    struct is_functor<R (&)(Args...)> : std::true_type {};

#ifndef RTTR_NO_CXX17_NOEXCEPT_FUNC_TYPE
    template<typename R, typename... Args>
    struct is_functor<R (*)(Args...) noexcept> : std::true_type {};

    template<typename R, typename... Args>
    struct is_functor<R (&)(Args...) noexcept> : std::true_type {};
#endif

    /////////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////////

    template <typename T>
    struct function_traits : function_traits< decltype(&T::operator()) > {};

    template<typename R, typename... Args>
    struct function_traits<R (Args...)>
    {
        static RTTR_CONSTEXPR_OR_CONST size_t arg_count = sizeof...(Args);

        using return_type   = R;
        using arg_types     = std::tuple<Args...>;
    };

    template<typename R, typename... Args>
    struct function_traits<R (*)(Args...)> : function_traits<R (Args...)> { };

    template<typename R, typename... Args>
    struct function_traits<R (&)(Args...)> : function_traits<R (Args...)> { };

    template<typename R, typename C, typename... Args>
    struct function_traits<R (C::*)(Args...)> : function_traits<R (Args...)> { using class_type = C; };

    template<typename R, typename C, typename... Args>
    struct function_traits<R (C::*)(Args...) const> : function_traits<R (Args...)> { using class_type = C; };

    template<typename R, typename C, typename... Args>
    struct function_traits<R (C::*)(Args...) volatile> : function_traits<R (Args...)> { using class_type = C; };

    template<typename R, typename C, typename... Args>
    struct function_traits<R (C::*)(Args...) const volatile> : function_traits<R (Args...)> {using class_type = C; };

#ifndef RTTR_NO_CXX17_NOEXCEPT_FUNC_TYPE
    template<typename R, typename... Args>
    struct function_traits<R (*)(Args...) noexcept> : function_traits<R (Args...)> { };

    template<typename R, typename... Args>
    struct function_traits<R (&)(Args...) noexcept> : function_traits<R (Args...)> { };

    template<typename R, typename C, typename... Args>
    struct function_traits<R (C::*)(Args...) noexcept> : function_traits<R (Args...)> { using class_type = C; };

    template<typename R, typename C, typename... Args>
    struct function_traits<R (C::*)(Args...) const noexcept> : function_traits<R (Args...)> { using class_type = C; };

    template<typename R, typename C, typename... Args>
    struct function_traits<R (C::*)(Args...) volatile noexcept> : function_traits<R (Args...)> { using class_type = C; };

    template<typename R, typename C, typename... Args>
    struct function_traits<R (C::*)(Args...) const volatile noexcept> : function_traits<R (Args...)> {using class_type = C; };
#endif

    template<typename T>
    struct function_traits<std::function<T>> : function_traits<T> {};

    /////////////////////////////////////////////////////////////////////////////////////
    // use it like e.g:
    // param_types<F, 0>::type

    template<typename F, size_t Index>
    struct param_types
    {
        using type = typename std::tuple_element<Index, typename function_traits<F>::arg_types>::type;
    };

    template<typename F, size_t Index>
    using param_types_t = typename param_types<F, Index>::type;

    /////////////////////////////////////////////////////////////////////////////////////

    template<typename F>
    struct is_void_func : conditional_t< std::is_same<typename function_traits<F>::return_type, void>::value,
                                         std::true_type,
                                         std::false_type
                                       >
    {
    };

    /////////////////////////////////////////////////////////////////////////////////////
    // returns an std::true_type, when the given type F is a function type; otherwise an std::false_type.
    template<typename F>
    using is_function = std::integral_constant<bool, std::is_member_function_pointer<F>::value ||
                                                     std::is_function<F>::value ||
                                                     is_functor<F>::value
                                              >;

    /////////////////////////////////////////////////////////////////////////////////////

} // end namespace detail
} // end namespace rttr

#endif // RTTR_FUNCTION_TRAITS_H_