#ifndef BOOST_TYPE_TRAITS_SIGNATURE_OF_HPP_INCLUDED
#define BOOST_TYPE_TRAITS_SIGNATURE_OF_HPP_INCLUDED

#include <boost/type_traits/integral_constant.hpp>
#include <boost/type_traits/is_member_function_pointer.hpp>
#include <functional>
#include <tuple>

namespace boost
{
//	a more flexible variant of result_of is needed
namespace detail
{
template <auto Call> struct result_of
{
protected:
	template <typename Function, bool IsMethod = boost::is_member_function_pointer<Function>::value> struct switch_call
	{
		using type = typename decltype(std::mem_fn(Function{}))::result_type;
	};
	template <typename Function> struct switch_call<Function, false>
	{
		using type = typename decltype(std::function(Function{}))::result_type;
	};

public:
	using type = typename switch_call<decltype(Call)>::type;
};

template <auto Call>
	using result_of_t = typename result_of<Call>::type;
}	//	detail


template <auto Call> struct argument_of
{
protected:
	//	operator()
	template <typename Class>
	struct switch_call : switch_call<decltype(&Class::operator())> {};

	//	function
	template <typename Function, typename... Args>
	struct switch_call<Function(*)(Args...)>
	{
		using type = std::tuple<Args...>;
	};
	template <typename Function, typename... Args>
	struct switch_call<Function(*)(Args...) noexcept>
	{
		using type = std::tuple<Args...>;
	};

	//	method
	template <typename Method, typename Class, typename... Args>
	struct switch_call<Method(Class::*)(Args...)>
	{
		using type = std::tuple<Args...>;
	};
	template <typename Method, typename Class, typename... Args>
	struct switch_call<Method(Class::*)(Args...) const>
	{
		using type = std::tuple<Args...>;
	};
	template <typename Method, typename Class, typename... Args>
	struct switch_call<Method(Class::*)(Args...) noexcept>
	{
		using type = std::tuple<Args...>;
	};
	template <typename Method, typename Class, typename... Args>
	struct switch_call<Method(Class::*)(Args...) const noexcept>
	{
		using type = std::tuple<Args...>;
	};

public:
	using type = typename switch_call<decltype(Call)>::type;
};


template <auto Call>
	using argument_of_t = typename argument_of<Call>::type;


template <auto Call> struct argument_size : integral_constant
<
	std::size_t,
	std::tuple_size_v<argument_of_t<Call>>
>	{};
template <auto Call>
	inline constexpr std::size_t argument_size_v = argument_size<Call>::value;


template <auto Call> struct signature_of
{
	using argument_type	= argument_of_t<Call>;
	using result_type	= detail::result_of_t<Call>;
};
}	//	boost

#endif	//	BOOST_TYPE_TRAITS_SIGNATURE_OF_HPP_INCLUDED