Specific case of unrolling an array to a function with arbitrary number and type of arguments

Question

Important!

Existing answers imply that all function parameter types are the same, only the number of parameters varies.

For instance : Any Solution to Unpack a Vector to Function Arguments in C++?

It's not possible to use return func(args[I]...) from the solution since each parameter has to be converted to a specific type

The question

I have two well defined types:

class Dest;
class A;

I have a safe_vector template class that is a std::vector with a safevalue(i) function that returns a default constructed value if i is out of bounds.

I have a template function which returns a type T from an argument of type A.

template<typename T>
T factory(A a);

Now I have a set of arbitrary functions:

void f_a(Dest * dest, T1 a, T2 b, T3 c);
void f_b(Dest * dest, T2 a);
void f_c(Dest * dest, T4 a, T1 b);
void f_d(Dest * dest, T4 a, T1 b, T1 c, T3 d);
void f_e(Dest * dest, T4 a, T1 b);

And I need to give these functions as callback functions of type:

void * (Dest * dest, const std::safe_vector<A> & args)

For instance:

addCallback("f_a", [](Dest * dest, const std::safe_vector<A> & args)
                {
                    f_a(dest,
                        factory<T1>(args.safe_value(0)),
                        factory<T2>(args.safe_value(1)),
                        factory<T3>(args.safe_value(2))   );
                });

Is there any method of doing this with a variadic template function that will automatically deduce the argument list from the function signature, and properly do the argument unroll?

I have some ideas but they imply recursive lambda functions, which will be runtime recursive and that's ugly

The context

A is a variant type from a scripting language. Some function of that scripting language are hooked to C++ functions. The factory function just converts the variant type to the required C++ classes. There are a lot of functions to hook, hence the need for a clean, variable argument template to do the job. Currently C++ callbacks take the variant array as a parameter and extract/convert the values internally, which makes them poorly readable.

Looks like you are asking for [this](https://stackoverflow.com/questions/11044504/any-solution-to-unpack-a-vector-to-function-arguments-in-c) — NathanOliver, Mar 31 '21 at 13:49
Except that the arguments are not all the same type, but there is the factory function which converts vector template type to each possible argument type — galinette, Mar 31 '21 at 13:57
I know that answer, but here it doesn't apply, or if it applies, the extra complexity is not straightforward — galinette, Mar 31 '21 at 13:58
why does it not apply? Is your problem not solved when you can write a `call(f_a,dest,args)` as I proposed? The linked Q&A is what you need to write such function — 463035818_is_not_an_ai, Mar 31 '21 at 14:06
@largest_prime_is_463035818 there is an extra conversion : each vector value must be converted to a specific type depending on the function signature. See my edit — galinette, Mar 31 '21 at 14:16
@largest_prime_is_463035818 Yes precisely! If there weren't there the case would be simple and a classic unrolling — galinette, Mar 31 '21 at 14:18
I guess I need some tuple use but I can't figure out how to write this — galinette, Mar 31 '21 at 14:19
my first idea is to refactor it to `factory` then you can apply the dupe. Or use a `tuple` so that you can access the types in the tuple in fold expressions — 463035818_is_not_an_ai, Mar 31 '21 at 14:19
well, ok you need some lookup of parameter types depending on the function because the functions are not taking `T1,T2,T3,...` in that order. — 463035818_is_not_an_ai, Mar 31 '21 at 14:21
reopened. unfortunately I can't write an answer atm, but I guess someone else will — 463035818_is_not_an_ai, Mar 31 '21 at 14:22
you say "arbitrary set of functions" but in your example all functions have different signature, if thats the case in your real case, there is a not so complicated solution — 463035818_is_not_an_ai, Mar 31 '21 at 14:44
@largest_prime_is_463035818 unfortunately a lot have different signatures — galinette, Mar 31 '21 at 15:03
sorry, maybe i wasnt clear, what would help is if they all have different signature. Because then from the type of the function alone you can identify the function. If two have same signature that doesnt work. well after your edit it seems like that not the case — 463035818_is_not_an_ai, Mar 31 '21 at 15:04

Specific case of unrolling an array to a function with arbitrary number and type of arguments

0 Answers0