How to write a generic templated wrapper for type specific acess functions?

Question

I'm trying to write a generic wrapper for the C++ pugi xml library that can save and store values to/from xml.

They have implemented their xml node attributes' (stored as strings) access functions into functions such as attribute.as_int(), attribute.as_bool() etc.

I want to achieve the same functionality seen in the nlohmann::json library where you can call .get<T>() on some json object and get some type.

The only way I can think of (which may not even work) is to use template specialization:

template <>
int foo<int>(xml_attribute param)
{
    return param.as_int();
}

template <>
bool foo<bool>(xml_attribute param)
{
    return param.as_bool();
}

And so forth.

Which seems to result in almost as much code as writing a non-generic wrapper...

The wrapper should have more code, but after, you can use foo in a generic way. — Jarod42, Apr 10 '19 at 21:51

score 2 · Answer 1 · edited Apr 10 '19 at 22:11

2

Well, your approach is actually not that bad. I'll probably stick with it.

There is another way, however.

#include <type_traits>

template <typename T>
auto foo(xml_attribute param)
{
    if constexpr (std::is_same<T, int>::value) {
          return param.as_int();
    }
    else if constexpr (/*..*/){//...} //and so on
}

edited Apr 10 '19 at 22:11

Jarod42

203,559
14
181
302

answered Apr 10 '19 at 21:55

Petar Velev

2,305
12
24

Alecto Irene Perez · Accepted Answer · 2019-04-10T23:16:11.473

We can use an extra parameter to create different overloads based on type, and then use overload resolution to find the right function. TypeTag is an empty class we can use to distinguish between different overloads:

template<class T>
struct TypeTag{ /* empty */ };

Once we have that, we can write read_as functions based on the tag:

int read_as(xml_attribute param, TypeTag<int>) {
    return param.as_int(); 
}
bool read_as(xml_attribute param, TypeTag<bool>) {
    return param.as_bool(); 
}
float read_as(xml_attribute param, TypeTag<float>) {
    return param.as_float(); 
}
double read_as(xml_attribute param, TypeTag<double>) {
    return param.as_double();
}
const pugi::char_t* read_as(xml_attribute param, TypeTag<const pugi::char_t*) {
    return param.as_string(); 
}

Making a generic template is now pretty simple:

template<class T>
T read_as(xml_attribute param) {
    return read_as(param, TypeTag<T>()); 
}

This solution works in C++11, and it will compile faster than a series of if constexpr checks because the compiler can look up the correct version through overload resolution, rather than having to do a series of checks.

Thanks, this is what I was trying to do but didn't understand exactly how. — jpsalm, Apr 11 '19 at 14:23

How to write a generic templated wrapper for type specific acess functions?

2 Answers2