For-loop with conditional call of a variadic amount of functions - c++

Question

Instead of performing recursive calls, I want an arbitrary number of functions to trigger based on some condition in a loop.
How do I transform method0, method1 to be called for a variadic number of typename ... methods?
Edit:
As you cannot return a variadic number of types, I modified the example a litte.
template <typename method0, typename method1, typename ... Args>
void loop(Args ... args)
{
for (int i = 0; i < iter_max; i++)
{
if (method0::condition(args))
{
method0::call_modify(args);
}
if (method1::condition(args))
{
method1::call_modify(args);
}
//...
}
}
template<typename ... Args>
struct method0
{
static bool condition(Args& ... args)
{
//Trigger condition
}
static void call_modify(Args& ... args)
{
//Perform action on args
}
};

Answer 1

You can do it like this:
#include <iostream>
template<typename ... Args>
struct method0
{
static bool condition(Args& ... args)
{
std::cout << "condition \n";
return true;
}
static void call(Args& ... args)
{
std::cout << "call\n";
}
};
template <typename... Methods, typename ... Args>
void loop(Args ... args)
{
auto apply = []<typename m>(auto&... a){
if (m::condition(a...)) m::call(a...);
};
(apply.template operator()<Methods>(args...), ...);
}
int main() {
loop<method0<int,int>,method0<int,int>>(1,2);
}
Output:
condition
call
condition
call
Perhaps loop should take references too in that case. And I ommitted the loop, it should be trivial to add it.
This is the old version of the answer for the slightly simpler case of non-variadic condition and call:
struct A {
static bool condition(int x) {
std::cout << "A::condition " << x << "\n";
return true;
}
static int call(int) {
std::cout << "A::call\n";
return 42;
}
};
struct B {
static bool condition(int x) {
std::cout << "B::condition " << x << "\n";
return false;
}
static int call(int) {
std::cout << "B::call\n";
return 0;
}
};
You can make loop call n-th types condition and call with n-th args like this:
template <typename... Methods, typename ... Args>
void loop(Args ... args)
{
auto apply = []<typename m>(auto& a){
if (m::condition(a)) a = m::call(a);
};
(apply.template operator()<Methods>(args), ...);
}
int main() {
loop<A,B>(1,2);
}
Output:
A::condition 1
A::call
B::condition 2

Answer 2

I managed to generalize 463035818_is_not_a_number's answer to be looped, and to take on a variadic number of input arguments. Full working example:
#include <iostream>
struct method0
{
static bool condition(double &arg1, double &arg2)
{
// Trigger condition
return (arg1 <= arg2);
}
static void call_modify(double &&arg1, double &&arg2)
{
std::cout << "method0!" << std::endl;
arg1 += 1;
}
};
struct method1
{
static bool condition(double &arg1, double &arg2)
{
// Trigger condition
return (arg1 > arg2);
}
static void call_modify(double &&arg1, double &&arg2)
{
std::cout << "method1!" << std::endl;
arg1 -= 1;
}
};
template <int iter_max, typename... Methods>
struct wrapper
{
template <typename... Args>
static void loop(Args &...args)
{
auto apply = []<typename m>(auto&&... a)
{
if (m::condition(a...))
m::call_modify(std::forward<Args>(a)...);
};
for (int i = 0; i < iter_max; i++)
{
(apply.template operator()<Methods>(std::forward<Args>(args)...), ...);
}
}
};
int main()
{
double arg1 = 2.0;
double arg2 = 0.;
constexpr int iter_max = 5;
wrapper<iter_max, method0, method1>::loop<double, double>(arg1, arg2);
}
output:
method1!
method1!
method0!
method1!
method0!
method1!
method0!
method1!