vmap/libs/generic/functional.h

#if !defined( INCLUDED_FUNCTIONAL_H )
#define INCLUDED_FUNCTIONAL_H

#include <functional>
#include <tuple>

namespace detail {

template<int N>
struct rank : rank<N - 1> {
};

template<>
struct rank<0> {
};

struct get_func {

	template<class T>
	struct wrapper {
		using type = T;
	};

	template<class F>
	using func_member = wrapper<typename F::func>;

	template<class F>
	static wrapper<func_member<F> > test(rank<2>) {
		return {};
	}

	template<class F>
	struct func_lambda {
		using type = typename func_lambda<decltype(&F::operator())>::type;
	};

	template<class R, class ... Ts>
	struct func_lambda<R (*)(Ts...)> {
		using type = R(Ts ...);
	};

	template<class Object, class R, class ... Ts>
	struct func_lambda<R (Object::*)(Ts...) const> {
		using type = R(Ts ...);
	};

	template<class Object, class R, class ... Ts>
	struct func_lambda<R (Object::*)(Ts...)> {
		using type = R(Ts ...);
	};

	template<class F, class = func_lambda<F> >
	static wrapper<func_lambda<F> > test(rank<1>) {
		return {};
	}
};

template<class F>
struct Fn;

template<class R, class ... Ts>
struct Fn<R(Ts...)> {
	using result_type = R;

	template<int N>
	using get = typename std::tuple_element<N, std::tuple<Ts...> >::type;
};
}

template<class Caller>
using get_func = typename decltype(detail::get_func::test<Caller>(detail::rank<2>{}))::type::type;

template<class Caller>
using get_result_type = typename detail::Fn<get_func<Caller> >::result_type;

template<class Caller, int N>
using get_argument = typename detail::Fn<get_func<Caller> >::template get<N>;

namespace detail {

template<class F>
class FunctionN;

template<class R, class ... Ts>
class FunctionN<R(Ts...)> {
public:
template<R(*f)(Ts...)>
class instance {
public:
using func = R(Ts ...);

static R call(Ts... args) {
	return (f)(args ...);
}
};
};

}

template<class F, F *func>
using Function = typename detail::FunctionN<F>::template instance<func>;

namespace detail {
template<class Object, class F>
struct MemberFunction;

template<class Object, class R, class ... Ts>
struct MemberFunction<Object, R(Ts...)> {
	using type = R (Object::*)(Ts...);
	using type_const = R (Object::*)(Ts...) const;
};
}

namespace detail {
template<class Object, class F>
class MemberN;

template<class Object, class R, class ... Ts>
class MemberN<Object, R(Ts...)> {
public:
template<R(Object::*f)(Ts...)>
class instance {
public:
using func = R(Object &, Ts ...);

static R call(Object &object, Ts... args) {
	return (object.*f)(args ...);
}
};
};
}

template<class Object, class F>
using MemberFunction = typename detail::MemberFunction<Object, F>::type;

template<class Object, class F, MemberFunction<Object, F> func>
using Member = typename detail::MemberN<Object, F>::template instance<func>;

namespace detail {
template<class Object, class F>
class ConstMemberN;

template<class Object, class R, class ... Ts>
class ConstMemberN<Object, R(Ts...)> {
public:
template<R(Object::*f)(Ts...) const>
class instance {
public:
using func = R(const Object &, Ts ...);

static R call(const Object &object, Ts... args) {
	return (object.*f)(args ...);
}
};
};
}

template<class Object, class F>
using ConstMemberFunction = typename detail::MemberFunction<Object, F>::type_const;

template<class Object, class F, ConstMemberFunction<Object, F> func>
using ConstMember = typename detail::ConstMemberN<Object, F>::template instance<func>;

// misc

namespace detail {
template<int ...>
struct seq {
};

template<int N, int... S>
struct gens : gens<N - 1, N - 1, S...> {
};

template<int... S>
struct gens<0, S...> {
	using type = seq<S...>;
};

template<int N>
using seq_new = typename gens<N>::type;

template<class Functor, class F>
class FunctorNInvoke;

template<class Functor, class R, class ... Ts>
class FunctorNInvoke<Functor, R(Ts...)> {
std::tuple<Ts...> args;

template<class T>
struct caller;

template<int ... I>
struct caller<seq<I...> > {
	static inline R call(FunctorNInvoke<Functor, R(Ts...)> *self, Functor functor) {
		(void) self;
		return functor(std::get<I>(self->args)...);
	}
};

public:
FunctorNInvoke(Ts... args) : args(args ...) {
}

inline R operator()(Functor functor) {
	return caller<seq_new<sizeof...(Ts)> >::call(this, functor);
}
};
}

template<class Functor>
using FunctorInvoke = detail::FunctorNInvoke<Functor, get_func<Functor> >;

#endif