How would I 'generate variadic parameters'? - c++

Question

I need a way to pass a variable amount of parameters to a function in this circumstance:
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 I now need a way to call my function with all of those values
member->*functionPointer(returnedLuaValues);
}
};
How would I go about doing this?

Answer 1

So I stole some of Luc Danton's sequence advice to sFuller and Pubby (about sequences), and I generated this "stop messing around with operator," version:
#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 can be out of order (ie, it can ask for arg 2 from Lua before arg 1), but the right one will be passed to the right argument.
Here is a test run: http://ideone.com/XVmQQ6

Answer 2

If I understand correctly, you should change the definition Lunch to invoke the member function pointer:
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))...
};
}
};