FunctionMatching.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_IMPL_FUNCTION_MATCHIN_HEADER_FILE
#define AI_TOOLBOX_IMPL_FUNCTION_MATCHIN_HEADER_FILE
 
#include <tuple>
 
#include <AIToolbox/TypeTraits.hpp>
 
namespace AIToolbox::Impl {
    template <typename T>
    struct GetFunctionArguments;
 
    template <typename R, typename... Args>
    struct GetFunctionArguments<R(*)(Args...)> {
        using args = std::tuple<Args...>;
        using rettype = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct GetFunctionArguments<R(C::*)(Args...)> {
        using args = std::tuple<Args...>;
        using rettype = R;
    };
 
    template <typename R, typename C, typename... Args>
    struct GetFunctionArguments<R(C::*)(Args...) const> : GetFunctionArguments<R(C::*)(Args...)> {};
 
    template <size_t... IDs> struct IdPack {};
 
    template <size_t N, typename T, typename U, size_t... IDs>
    struct Matcher {
        static constexpr bool match = false;
        using type = IdPack<IDs...>;
    };
 
    template <size_t N, typename... B, size_t... IDs>
    struct Matcher<N, std::tuple<>, std::tuple<B...>, IDs...> {
        static constexpr bool match = true;
        using type = IdPack<IDs...>;
    };
 
    template <size_t N, typename F, typename... A, typename... B, size_t... IDs>
    struct Matcher<N, std::tuple<F, A...>, std::tuple<F, B...>, IDs...> {
        using M = Matcher<N+1, std::tuple<A...>, std::tuple<B...>, IDs..., N>;
        static constexpr bool match = M::match;
        using type = typename M::type;
    };
 
    template <size_t N, typename FA, typename... A, typename FB, typename... B, size_t... IDs>
    struct Matcher<N, std::tuple<FA, A...>, std::tuple<FB, B...>, IDs...> {
        using M = std::conditional_t<
                    std::is_constructible_v<FA, FB> &&
                    std::is_same_v<std::remove_cvref_t<FA>, std::remove_cvref_t<FB>>,
                    Matcher<N+1, std::tuple<A...>, std::tuple<B...>, IDs..., N>,
                    Matcher<N+1, std::tuple<FA, A...>, std::tuple<B...>, IDs...>
                >;
        static constexpr bool match = M::match;
        using type = typename M::type;
    };
 
    template <typename T, typename F>
    struct is_compatible_f {
        static constexpr bool value = false;
    };
 
    template <typename R, typename... Args, typename R2, typename... Args2>
    struct is_compatible_f<R(Args...), R2(Args2...)> {
        static constexpr bool value = std::is_same<R, R2>::value &&
                                      Matcher<0, std::tuple<Args...>, std::tuple<Args2...>>::match;
    };
 
    template <typename R, typename C, typename... Args, typename R2, typename... Args2>
    struct is_compatible_f<R(C::*)(Args...), R2(Args2...)> : is_compatible_f<R(Args...), R2(Args2...)> {};
 
    template <typename R, typename C, typename... Args, typename R2, typename... Args2>
    struct is_compatible_f<R(C::*)(Args...) const, R2(Args2...)> : is_compatible_f<R(C::*)(Args...), R2(Args2...)> {};
 
    template <typename F, typename... Args, size_t... IDs>
    void caller(F f, std::tuple<Args...> && args, IdPack<IDs...>) {
        f(std::forward<std::tuple_element_t<IDs, std::tuple<Args...>>>(std::get<IDs>(args))...);
    }
 
    template <typename C, typename F, typename... Args, size_t... IDs>
    void caller(C & c, F f, std::tuple<Args...> && args, IdPack<IDs...>) {
        (c.*f)(std::forward<std::tuple_element_t<IDs, std::tuple<Args...>>>(std::get<IDs>(args))...);
    }
 
    template <typename F, typename... Args>
    void callFunction(F f, Args&& ...args) {
        using FArgs = typename GetFunctionArguments<F>::args;
        using IdList = typename Matcher<0, FArgs, std::tuple<Args...>>::type;
 
        caller(f, std::forward_as_tuple(args...), IdList());
    }
 
    template <typename C, typename F, typename... Args>
    void callFunction(C & c, F f, Args&& ...args) {
        using FArgs = typename GetFunctionArguments<F>::args;
        using IdList = typename Matcher<0, FArgs, std::tuple<Args...>>::type;
        static_assert(Matcher<0, FArgs, std::tuple<Args...>>::match);
 
        caller(c, f, std::forward_as_tuple(args...), IdList());
    }
 
}
 
#endif