Elegantly attempt to execute various functions a specific way

Question

I'm attempting to execute various functions sequentially n number of times, only moving forward if previous function did not return false (error) otherwise I reset and start all over again.

An example of a sequence would be :

1. Turn module ON : module.power(true), 3 attempts
2. Wait for a signal : module.signal(), 10 attempts
3. Send a message : module.sendSMS('test'), 3 attempts
4. Turn module OFF : module.power(false), 1 attempt

Each of those actions are done the same way, only changing the DEBUG text and the function to launch :

DEBUG_PRINT("Powering ON");  // This line changes
uint8_t attempts = 0;
uint8_t max_attempts = 3;  // max_attempts changes
while(!module.power(true) && attempts < max_attempts){  // This line changes
  attempts++;
  DEBUG_PRINT(".");
  if(attempts == max_attempts) {
    DEBUG_PRINTLN(" - Failed.");
    soft_reset();  // Start all over again
  }
  delay(100);
}
DEBUG_PRINTLN(" - Success");
wdt_reset(); // Reset watchdog timer, ready for next action

Is there an elegant way I can put this process in a function I could call to execute the required functions this particular way, for example something like :

void try_this_action(description, function, n_attempts)

Which would make actions 1-4 above like :

try_this_action("Powering ON", module.power(true), 3);
try_this_action("Waiting for signal", module.signal(), 10);
try_this_action("Sending SMS", module.sendSMS('test'), 3);
try_this_action("Powering OFF", module.power(false), 1);

A difficulty I have is that the functions called have different syntax (some take parameters, some other don't...). Is there a more elegant modulable way of doing this besides copy/paste the chunck of code everywhere I need it ?

Answer 1

You can use a variadic function, declaring in the parameter list first those parameters that are always present, then the variable part. In following code we define a type for action functions, void returning having as parameter an argument list:

typedef void (*action)(va_list);

Then define the generic action routine that prepare for the action execution:

void try_this_action(char *szActionName, int trials, action fn_action, ...)
{
    va_list args;
    va_start(args, fn_action);    //Init the argument list

    DEBUG_PRINT(szActionName);  // This line changes
    uint8_t attempts = 0;
    uint8_t max_attempts = trials;  // max_attempts changes
    //Here we call our function through the pointer passed as argument
    while (!fn_action(args) && attempts < max_attempts)
    {   // This line changes
        attempts++;
        DEBUG_PRINT(".");
        if (attempts == max_attempts)
        {
            DEBUG_PRINTLN(" - Failed.");
            soft_reset();   // Start all over again
        }
        delay(100);
    }
    DEBUG_PRINTLN(" - Success");
    wdt_reset();    // Reset watchdog timer, ready for next action
    va_end(args);
}

Each function must be coded to use an argument list:

int power(va_list args)
{
    //First recover all our arguments using the va_arg macro
    bool cond = va_arg(args, bool);

    if (cond == true)
    {
        ... //do something
            return true;
    }
    return false;
}

The usage will be:

try_this_action("Powering ON", 3, module.power, true);
try_this_action("Waiting for signal", 10, module.signal);
try_this_action("Sending SMS", 3, module.sendSMS, "test");
try_this_action("Powering OFF", 1, module.power, false);

If you need more info on variadic functions and usage of stdarg.h macros google the net. Start from here https://en.cppreference.com/w/c/variadic.

It could be coded also as a macro implementation, as the excellent proposal in the John Bollinger answer, but in that case you must consider that each macro usage will instantiate the whole code, that could be eventually even better for speed (avoiding a function call), but could be not suitable on systems with limited memory (embedded), or where you need reference to the function try_this_action (inexistent).

Answer 2

Functions of different arity may be abstracted with a generic signature (think about main). Instead of each giving each their own unique arguments, you simply supply them all with:

1. An argument count.
2. A vector of pointers to the arguments.

This is how your operating system treats all programs it runs anyways. I've given a very basic example below which you can inspect.

#include <stdio.h>
#include <stdlib.h>

/* Define total function count */
#define MAX_FUNC        2

/* Generic function signature */
typedef void (*func)(int, void **, const char *);

/* Function pointer array (NULL - initialized) */
func functions[MAX_FUNC];

/* Example function #1 */
void printName (int argc, void **argv, const char *desc) {
    fprintf(stdout, "Running: %s\n", desc);
    if (argc != 1 || argv == NULL) {
        fprintf(stderr, "Err in %s!\n", desc);
        return;
    }
    const char *name = (const char *)(argv[0]);
    fprintf(stdout, "Name: %s\n", name);
}

/* Example function #2 */
void printMax (int argc, void **argv, const char *desc) {
    fprintf(stdout, "Running: %s\n", desc);
    if (argc != 2 || argv == NULL) {
        fprintf(stderr, "Err in %s!\n", desc);
        return;
    }
    int *a = (int *)(argv[0]), *b = (int *)(argv[1]);
    fprintf(stdout, "Max: %d\n", (*a > *b) ? *a : *b);
}


int main (void) {
    functions[0] = printName;               // Set function #0
    functions[1] = printMax;                // Set function #1


    int f_arg_count[2] = {1, 2};            // Function 0 takes 1 argument, function 1 takes 2.
    const char *descs[2] = {"printName", "printMax"};
    const char *name = "Natasi";            // Args of function 0
    int a = 2, b = 3;                       // Args of function 1
    int *args[2] = {&a, &b};                // Args of function 1 in an array.

    void **f_args[2] = {(void **)(&name), 
                      (void **)(&args)};    // All function args.

    // Invoke all functions.    
    for (int i = 0; i < MAX_FUNC; i++) {
        func f = functions[i];
        const char *desc = descs[i];
        int n = f_arg_count[i];
        void **args = f_args[i];
        f(n, args, desc);
    }

    return EXIT_SUCCESS;
}

Answer 3

A difficulty I have is that the functions called have different syntax (some take parameters, some other don't...).

That is indeed an issue. Along with it you have the possibility of variation in actual function arguments for the same function.

Is there a more elegant modulable way of doing this besides copy/paste the chunck of code everywhere I need it ?

I think you could make a variadic function that uses specific knowledge of the functions to dispatch in order to deal with the differing function signatures and actual arguments. I'm doubtful that I would consider the result more elegant, though.

I would be inclined to approach this job via a macro, instead:

// desc:     a descriptive string, evaluated once
// action:   an expression to (re)try until it evaluates to true in boolean context
// attempts: the maximum number of times the action will be evaluated, itself evaluated once
#define try_this_action(desc, action, attempts) do { \
    int _attempts = (attempts);                      \
    DEBUG_PRINT(desc);                               \
    while(_attempts && !(action)) {                  \
        _attempts -= 1;                              \
        DEBUG_PRINT(".");                            \
        delay(100);                                  \
    }                                                \
    if (_attempts) {                                 \
        DEBUG_PRINTLN(" - Success");                 \
    } else {                                         \
        DEBUG_PRINTLN(" - Failed.");                 \
        soft_reset();                                \
    }                                                \
    wdt_reset();                                     \
} while (0)

Usage would be just as you described:

try_this_action("Powering ON", module.power(true), 3);

etc.. Although the effect is as if you did insert the code for each action in each spot, using a macro such as this would yield code that is much easier to read, and that is not lexically repetitive. Thus, for example, if you ever need to change the the steps for trying actions, you can do it once for all by modifying the macro.

Answer 4

You need to make the function pointers all have the same signature. I would use something like this;

typedef int(*try_func)(void *arg);

And have a try_this_action(...) signature similar to the following;

void try_this_action(char * msg, int max_trys, try_func func, void *arg)

You would then implement your actions similar to this;

int power(void *pv)
{
    int *p = pv;    
    int on_off = *p;

    static int try = 0;

    if (on_off && try++)
        return 1;
    return 0;
}

int signal(void *pv)
{
    static int try = 0;

    if (try++ > 6)
        return 1;
    return 0;
}

And call them like this;

int main(int c, char *v[])
{
    int on_off = 1;

    try_this_action("Powering ON", 3, power, &on_off);
    try_this_action("Signaling", 10, signal, 0);
}