Question

In my current setup, I have a

typedef std::function<void (MyClass&, std::vector<std::string>) MyFunction;
std::map<std::string, MyFunction> dispatch_map;

And I register my functions in it with a macro. However, I have a problem with this: the parameters are passed as a vector of strings, which I have to convert inside the functions. I would rather do this conversion outside the functions, at the dispatcher level. Is this possible? The function signatures are known at compile time, and never change at run time.

Answer 1

You can get pretty far with variadic templates and some template/virtual techniques. With the following codes, you’ll be able to do something like:

std::string select_string (bool cond, std::string a, std::string b) {
    return cond ? a : b;
}

int main () {
    Registry reg;
    reg.set ("select_it", select_string);
    reg.invoke ("select_it", "1 John Wayne"));
    reg.invoke ("select_it", "0 John Wayne"));
}

output:

John
Wayne

---

Full implementation:

These codes are exemplary. You should optimize it to provide perfect forwarding less redundancy in parameter list expansion.

Headers and a test-function

#include <functional>
#include <string>
#include <sstream>
#include <istream>
#include <iostream>
#include <tuple>

std::string select_string (bool cond, std::string a, std::string b) {
    return cond ? a : b;
}

This helps us parsing a string and putting results into a tuple:

//----------------------------------------------------------------------------------

template <typename Tuple, int Curr, int Max> struct init_args_helper;

template <typename Tuple, int Max>
struct init_args_helper<Tuple, Max, Max> {
    void operator() (Tuple &, std::istream &) {}
};

template <typename Tuple, int Curr, int Max>
struct init_args_helper {
    void operator() (Tuple &tup, std::istream &is) {
        is >> std::get<Curr>(tup);
        return init_args_helper<Tuple, Curr+1, Max>() (tup, is);
    }
};


template <int Max, typename Tuple>
void init_args (Tuple &tup, std::istream &ss)
{
    init_args_helper<Tuple, 0, Max>() (tup, ss);
}

This unfolds a function pointer and a tuple into a function call (by function-pointer):

//----------------------------------------------------------------------------------

template <int ParamIndex, int Max, typename Ret, typename ...Args>
struct unfold_helper;

template <int Max, typename Ret, typename ...Args>
struct unfold_helper<Max, Max, Ret, Args...> {
    template <typename Tuple, typename ...Params>
    Ret unfold (Ret (*fun) (Args...), Tuple tup, Params ...params)
    {
        return fun (params...);
    }
};

template <int ParamIndex, int Max, typename Ret, typename ...Args>
struct unfold_helper {
    template <typename Tuple, typename ...Params>
    Ret unfold (Ret (*fun) (Args...), Tuple tup, Params ...params)
    {
        return unfold_helper<ParamIndex+1, Max, Ret, Args...> ().
               unfold(fun, tup, params..., std::get<ParamIndex>(tup));
    }
};



template <typename Ret, typename ...Args>
Ret unfold (Ret (*fun) (Args...), std::tuple<Args...> tup) {
    return unfold_helper<0, sizeof...(Args), Ret, Args...> ().unfold(fun, tup);
}

This function puts it together:

//----------------------------------------------------------------------------------

template <typename Ret, typename ...Args>
Ret foo (Ret (*fun) (Args...), std::string mayhem) {

    // Use a stringstream for trivial parsing.
    std::istringstream ss;
    ss.str (mayhem);

    // Use a tuple to store our parameters somewhere.
    // We could later get some more performance by combining the parsing
    // and the calling.
    std::tuple<Args...> params;
    init_args<sizeof...(Args)> (params, ss);

    // This demondstrates expanding the tuple to full parameter lists.
    return unfold<Ret> (fun, params);
}

Here’s our test:

int main () {
    std::cout << foo (select_string, "0 John Wayne") << '\n';
    std::cout << foo (select_string, "1 John Wayne") << '\n';
}

Warning: Code needs more verification upon parsing and should use std::function<> instead of naked function pointer

---

Based on above code, it is simple to write a function-registry:

class FunMeta {
public:
    virtual ~FunMeta () {}
    virtual boost::any call (std::string args) const = 0;
};

template <typename Ret, typename ...Args>
class ConcreteFunMeta : public FunMeta {
public:
    ConcreteFunMeta (Ret (*fun) (Args...)) : fun(fun) {}

    boost::any call (std::string args) const {
        // Use a stringstream for trivial parsing.
        std::istringstream ss;
        ss.str (args);

        // Use a tuple to store our parameters somewhere.
        // We could later get some more performance by combining the parsing
        // and the calling.
        std::tuple<Args...> params;
        init_args<sizeof...(Args)> (params, ss);

        // This demondstrates expanding the tuple to full parameter lists.
        return unfold<Ret> (fun, params);
    }

private:
    Ret (*fun) (Args...);
};

class Registry {
public:
    template <typename Ret, typename ...Args>
    void set (std::string name, Ret (*fun) (Args...)) {
        funs[name].reset (new ConcreteFunMeta<Ret, Args...> (fun));
    }

    boost::any invoke (std::string name, std::string args) const {
        const auto it = funs.find (name);
        if (it == funs.end())
            throw std::runtime_error ("meh");
        return it->second->call (args);
    }

private:
    // You could use a multimap to support function overloading.
    std::map<std::string, std::shared_ptr<FunMeta>> funs;
};

One could even think of supporting function overloading with this, using a multimap and dispatching decisions based on what content is on the passed arguments.

Here’s how to use it:

int main () {
    Registry reg;
    reg.set ("select_it", select_string);
    std::cout << boost::any_cast<std::string> (reg.invoke ("select_it", "0 John Wayne")) << '\n'
              << boost::any_cast<std::string> (reg.invoke ("select_it", "1 John Wayne")) << '\n';
}