How will I generate variable parameters?

Question

I need a way to pass a variable number of function parameters in this case:

template<typename ...T> struct Lunch { Lunch(T...){} }; template<typename T> T CheckLuaValue(lua_State* luaState,int index) { //Do Stuff return value; } template <class MemberType, typename ReturnType, typename... Params> struct MemberFunctionWrapper <ReturnType (MemberType::*) (Params...)> { static int CFunctionWrapper (lua_State* luaState) { ReturnType (MemberType::*)(Params...) functionPointer = GetFunctionPointer(); MemberType* member = GetMemberPointer(); int index = 1; //Get a value for each type in Params Lunch<Params...> { (CheckLuaValue<Params>(luaState,index), index++, void(), 0)... }; 

CheckLuaValue returns a value for each type in Params. My problem is that now I need a way to call my function with all these values

  member->*functionPointer(returnedLuaValues); } }; 

How should I do it?

Answer 1

So, I stole some of the Luc Danton sequence recommendations for sFuller and Pubby (about sequences), and I created this version of "stop messing around with operator, ":

 #include <iostream> struct lua_State {}; template<typename T> T CheckLuaValue( int n, lua_State* l) { std::cout << "arg[" << n << "] gotten\n"; return T(n); } template<int ...> struct seq { }; // generates a seq< First, ..., Last-1 > as "type" template<int First, int Last> struct gen_seq { template<int N, int... S> struct helper : helper<N-1, N-1, S...> {}; template<int... S> struct helper<First, S...> { typedef seq<S...> type; }; typedef typename helper<Last>::type type; }; template< typename X > struct MemberFunctionWrapper; template< typename F > struct MemberFunctionHelper { typedef F MethodPtr; }; template<class InstanceType, typename ReturnType, typename... Params> struct MemberFunctionWrapper< ReturnType(InstanceType::*)(Params...) > { typedef MemberFunctionHelper<ReturnType(InstanceType::*)(Params...)> Helper; typedef typename Helper::MethodPtr MethodPtr; static MethodPtr& GetFunctionPointer() {static MethodPtr pFunc; return pFunc;} static InstanceType*& GetMemberPointer() {static InstanceType* pThis;return pThis;} template<int n, typename Param> static auto GetLuaValue( lua_State* luaState )->decltype(CheckLuaValue<Param>(n,luaState)) { return CheckLuaValue<Param>(n,luaState); } template< typename sequence > struct call; template< int... I > struct call<seq<I...>> { ReturnType operator()( lua_State* luaState, InstanceType* instance, MethodPtr method ) const { return (instance->*method)( GetLuaValue<I,Params>( luaState )... ); } }; static int CFunctionWrapper( lua_State* luaState) { MethodPtr func = GetFunctionPointer(); InstanceType* instance = GetMemberPointer(); ReturnType retval = call< typename gen_seq< 1, sizeof...(Params)+1 >::type >()( luaState, instance, func ); return 0; } }; struct test{ int foo(int x, double d){std::cout << "x:" << x << " d:" << d << "\n";}}; int main(){ typedef MemberFunctionWrapper< int(test::*)(int, double) > wrapper; test bar; wrapper::GetFunctionPointer() = &test::foo; wrapper::GetMemberPointer() = &bar; wrapper::CFunctionWrapper(0); } 

now note that the calls to CheckLuaValue may be out of order (i.e. it may request arg 2 from Lua before arg 1), but the right one will be passed into the correct argument.

Here is a test run: http://ideone.com/XVmQQ6

Answer 2

If I understand correctly, you should change the definition of Lunch to call a pointer to a member function:

 template <class MemberType, typename ReturnType, typename... Params> struct MemberFunctionWrapper <ReturnType (MemberType::*) (Params...)> { template<typename ...T> struct foo // new Lunch { foo(ReturnType (MemberType::*)(Params...) functionPointer, MemberType* member, T... args){ member->*functionPointer(args...); } }; static int CFunctionWrapper (lua_State* luaState) { ReturnType (MemberType::*)(Params...) functionPointer = GetFunctionPointer(); MemberType* member = GetMemberPointer(); int index = 1; //member->*(bindedMemberFunction->memberFunction); //Get a value for each type in Params foo<Params...> { functionPointer, member, (++index, CheckLuaValue<Params>(luaState,index))... }; } };