#include <tuple>

class lua_State;
template <typename T>
T extract_data(lua_State* L){
    return T(); // Just do nothing, I don't need lua here.
}


template <unsigned int n>
class tuple_extractor{
public:
    template <typename T, typename ...ArgsOut, typename ...ArgsIn, typename ...ArgsPart>
    static void extractTuple(
            T* obj,
            void (T::*func)(ArgsOut...),
            const std::tuple<ArgsIn...>& inParams,
            ArgsPart... partParams){
        tuple_extractor<n-1>::extractTuple(obj, func, inParams, std::get<n-1>(inParams), partParams...);
    }
};

template <>
class tuple_extractor<0>{
public:
    template <typename T, typename ...ArgsOut, typename ...ArgsIn, typename ...ArgsPart>
    static void extractTuple(
            T* obj,
            void (T::*func)(ArgsOut...),
            const std::tuple<ArgsIn...>& inParams,
            ArgsPart... partParams){
        (obj->*func)(partParams...);
    }
};

// For last-to-first order use:
template <typename ...Args>
struct getTuple;

template <typename T, typename ...Args>
struct getTuple<T, Args...>{
    static inline std::tuple<T, Args...> get(lua_State* L){
        std::tuple<Args...> args = getTuple<Args...>::get(L);
        std::tuple<T> t = std::make_tuple<T>(extract_data<T>(L));
        return std::tuple_cat(t, args);
    }
};

template <>
struct getTuple<>{
    static inline std::tuple<> get(lua_State* L){
        return std::make_tuple<>();
    }
};

template <typename C, typename R, typename ... Args>
R extract_call(C* ths, lua_State* L, R(C::*method)(Args...))
{
    std::tuple<Args...> tmp = getTuple<Args...>::get(L);
    tuple_extractor<sizeof...(Args)>::extractTuple(ths, method, tmp);
}

class cls{
public:
    void method1(int, char, std::string){}
    void method2(int, double, cls*){}

};

int main(){

    cls c;
    lua_State* L = 0;

    extract_call(&c, L, &cls::method1 );
    extract_call(&c, L, &cls::method2 );

    return 0;
}