Convert initializer_list to variadic templates

Question

I use a formatting library called fmt (http://fmtlib.net/latest/).

One of the possible use is :

fmt::format("Hello, {name}! The answer is {number}. Goodbye, {name}.", fmt::arg("name", "World"), fmt::arg("number", 42));

I'd like to wrap this call in a function that I'd call as :

myFunction(myString, {"name", "World"}, {"number", 42});

for any number of arguments.

Up to now,I only succeeded to do a function callable with a list of pairs :

myFunction(myString, std::make_pair("name", "World"), std::make_pair("number", 42));

with the function :

std::string myFunction(const char* str, const Args&... rest) const
{
    return fmt::format(mLocale.getPOILabel(label), fmt::arg(rest.first, rest.second)...);
}

but I'd like not to have use pairs.

What should I do ?

PS : The fmt::arg cannot be passed between functions.

One can define a class with a templated constructor, i.e. `template arg(const char *name, T &&value)`, and `{"number", 42}` will then use uniform initialization syntax successfully to bind to the class, and construct it. However, I can't think of a way to define a function that takes a variadic list of `arg`s. Seems like a parameter pack does not like braced uniform initialization syntax... — Sam Varshavchik, Mar 16 '17 at 12:48
Your PS *cannot be true* as you pass them to `fmt::format`. I expect that it receives them only by rvalue reference — Caleth, Mar 16 '17 at 13:19

max66 · Answer 1 · 2017-03-16T14:28:33.700

Not exactly what do you asked, because you have to call your function as

myFunction(myString, "name", "World", "number", 42);

instead of

myFunction(myString, {"name", "World"}, {"number", 42});

but the following should be an example (sorry but baz() is untested)

#include <tuple>
#include <string>
#include <utility>
#include <iostream>

// fmt headers

template <typename ... Ps>
std::string baz (char const * frmt,
                 std::pair<char const *, Ps> const & ... ps)
 { return fmt::format(frmt, fmt::arg(ps.first, ps.second)...); }

template <typename ... Ts, std::size_t ... Is>
std::string bar (char const * frmt, std::tuple<Ts...> const & t,
                 std::index_sequence<Is...> const &)
 { return baz(frmt, std::get<Is>(t)...); }

template <typename ... Ts>
std::string foo (char const * frmt, std::tuple<Ts...> const & t)
 { return bar(frmt, t, std::make_index_sequence<sizeof...(Ts)>{}); }

template <typename ... Ts, typename P1, typename P2, typename ... Args>
std::string foo (char const * frmt, std::tuple<Ts...> const & t,
                 P1 const & p1, P2 const & p2, Args const & ... args)
 { return foo(frmt, 
      std::tuple_cat(t, std::make_tuple(std::make_pair(p1, p2))), args...); }

template <typename ... Args>
std::string myFunction (char const * frmt, Args const & ... args)
 { return foo(frmt, std::tuple<>{}, args...); }

int main()
 {
   myFunction("format", "name", "World", "number", 42);
 }

Observe that this example use std::index_sequence and std::make_index_sequence(), so compile starting from C++14; but it's easy to create a substitute for this class and this function to work with C++11 too.

score 0 · Answer 2 · answered Mar 16 '17 at 13:17

Try moving the results of fmt::arg, rather than copying or passing const references.

template<typename ... Args>
std::string myFunction(const char* str, Args&&... rest) const
{
    return fmt::format(mLocale.getPOILabel(label), std::forward<Args...>(rest)...);
}

myFunction(myString, fmt::arg("name", "World"), fmt::arg("number", 42));

Convert initializer_list to variadic templates

2 Answers2