Beautifying a variable templated function call

Question

I have the following C++ snippet:

template_par<std::string> a("name", "Joh Node");
template_par<int> b("age", 23);
std::string result = templater<SomeTemplateClass>().templatize(a, b).get();

Which tries to implement a template engine for various purposes. The important parts of the templater class are:

template<class T>
class templater
{
    std::map<std::string, std::string> kps;

public:

    template <typename T1>
    templater& templatize(template_par<T1> b)
    {
        kps.insert(make_pair(b.getKey(), to_string(b.getValue())));
        return *this;
    }


    template<typename T1, typename... Args1>
    templater& templatize(T1 first, Args1... args)
    {
        kps.insert(make_pair(first.getKey(), to_string(first.getValue())));
        return templatize(args...);
    }
}

ie. a template function with variable arguments .... template_par<T> are just template parameter classes for basic stuff. Right now as it is, this works, does the job nicely.

However, I would like to be able to shorten somehow the way I call the templatize method not only for aesthetics but also for a challenge... I think it would look much nicer something like:

  std::string result = templater<SomeTemplateClass>().templatize(
            "name" -> "Joh Node",
            "age"  -> 42
  );

However this approach is not feasible due to the operator -> being a somewhat rigid piece of C++ ... (std::string result = templater<SomeTemplateClass>().templatize is not the important part here, that can be hided in a friendly construct, I am more worried about the variable number of parameters)

Any good beautification ideas for the challenge above?

Answer 1

Take a look at Boost.Assign, in particular the map assignment part of it, which you could co-opt here:

std::string result = templater<SomeTemplateClass>()
    ("Name", "Joh Node")
    ("Age", 42).templatize();

I would avoid getting much more creative than that, it makes the code cryptic. That said, if you want to experiment wildly, you might like my named operators, which would allow syntax such as:

std::string result = templater<SomeTemplateClass>().templatize(
    "name" <is> "Joh Node",
    "age"  <is> 42
);

Here, is can be any valid C++ identifier. So conventional operators are unfortunately out, but pretty much everything flies. Even, if you really want to push it, <_>.