Can the wrapper functions be refactored - c++

Question

I have a collection of C++ functions that all accept a type from the same set of types (TypeA, TypeB and TypeC in the example below) as template parameter. To ease the exposition of these functions to python, I would like to define, for each of them, a function that takes the type not as template parameter, but as a string argument, as shown below:
template<typename dataType>
int function(int arg)
{
...
}
int function(int arg, string type)
{
if (type == "type_A")
{
return function<TypeA>(arg);
}
else if (type == "type_B")
{
return function<TypeB>(arg);
}
else if (type == "type_C")
{
return function<TypeC>(arg);
}
else
{
std::cerr << "Invalid type!" << std::endl;
exit(1);
}
}
At the moment, I wrap all the functions in this way, but this leads to a lot of code repetition, so I was wondering whether there was a better way to do this, perhaps using preprocessor directives?

Answer 1

One way to reduce the if/else logic is to store a map of std::function objects and use the map to make the right call.
int function(int arg, std::string type)
{
using FMap = std::map<std::string, std::function<int(int)>>;
static const FMap fmap{{"type_A", [](int arg) { return function<TypeA>(arg); }},
{"type_B", [](int arg) { return function<TypeB>(arg); }},
{"type_C", [](int arg) { return function<TypeC>(arg); }}};
auto iter = fmap.find(type);
if ( iter != fmap.end() )
{
return iter->second(arg);
}
std::cerr << "Invalid type!" << std::endl;
exit(1);
return 0;
}
If you are willing to rename the function template, you can simplify the code for constructing the function map.
template <typename T>
int fun_2(int arg) { ... }
int function(int arg, std::string type)
{
using FMap = std::map<std::string, std::function<int(int)>>;
static const FMap fmap{{"type_A", fun_2<TypeA>},
{"type_B", fun_2<TypeB>},
{"type_C", fun_2<TypeC>}};
auto iter = fmap.find(type);
if ( iter != fmap.end() )
{
return iter->second(arg);
}
std::cerr << "Invalid type!" << std::endl;
exit(1);
return 0;
}