Ambiguity errors with variadic templates and mixins - c++

Question

I am trying to create a callback registration class tat allows registration of callbacks against string identifier for different types. Each callback has the signature void function( T val ) where T is the changing type.
I have created the following base registrar class that maps strings to functions.
#include <string>
#include <map>
#include <functional>
#include <cstdint>
#include <iostream>
using namespace std;
template< typename ValueType >
class BasicConfigCallbackRegistrar
{
public:
typedef ValueType value_type;
typedef BasicConfigCallbackRegistrar< value_type > type;
typedef function< void( const value_type ) > signature_type;
typedef map< string, signature_type > callback_map_type;
/// #brief constructor
BasicConfigCallbackRegistrar() : callbackMap_()
{
}
/// #brief register a create callback
/// #param nodePath the path identifying the node in config database
/// #param callback the callback to register
type& RegisterCallback( string nodePath, signature_type callback )
{
callbackMap_.insert( make_pair( move(nodePath), callback ) );
return *this;
}
void MakeCallback( const string& nodePath, value_type val )
{
// no checking assumes item is in map,
// do not do this in production code
auto iter = callbackMap_.find( nodePath );
iter->second( val );
}
private:
callback_map_type callbackMap_; ///< the callback map
};
I then use variadic templates to create a derived class for each of the types I want to support.
template< typename... Types >
class ConfigCallbackRegistrar : public BasicConfigCallbackRegistrar<Types>...
{
public:
/// #brief constructor
ConfigCallbackRegistrar() : BasicConfigCallbackRegistrar<Types>()...
{}
};
This is then typedefed as:
typedef ConfigCallbackRegistrar< uint32_t, string > CallbackRegistrar;
When I try to use this class as follows:
struct UintFtor
{
void operator()( uint32_t val )
{
cout << val << "\n";
}
};
struct StringFtor
{
void operator ()( string val )
{
cout << val << "\n";
}
};
int main()
{
CallbackRegistrar registrar{};
registrar.RegisterCallback( "SomeNode", UintFtor() );
registrar.RegisterCallback( "SomeNode", StringFtor() );
return 0;
}
Unfortunately when I try to compile this I get the following ambiguity errors:
variadic-wrap.cpp: In function ‘int main()’:
variadic-wrap.cpp:87: error: request for member ‘RegisterCallback’ is ambiguous
variadic-wrap.cpp:27: error: candidates are: BasicConfigCallbackRegistrar<ValueType>& BasicConfigCallbackRegistrar<ValueType>::RegisterCallback(std::string, std::function<void(ValueType)>) [with ValueType = std::basic_string<char, std::char_traits<char>, std::allocator<char> >]
variadic-wrap.cpp:27: error: BasicConfigCallbackRegistrar<ValueType>& BasicConfigCallbackRegistrar<ValueType>::RegisterCallback(std::string, std::function<void(ValueType)>) [with ValueType = unsigned int]
variadic-wrap.cpp:88: error: request for member ‘RegisterCallback’ is ambiguous
variadic-wrap.cpp:27: error: candidates are: BasicConfigCallbackRegistrar<ValueType>& BasicConfigCallbackRegistrar<ValueType>::RegisterCallback(std::string, std::function<void(ValueType)>) [with ValueType = std::basic_string<char, std::char_traits<char>, std::allocator<char> >]
variadic-wrap.cpp:27: error: BasicConfigCallbackRegistrar<ValueType>& BasicConfigCallbackRegistrar<ValueType>::RegisterCallback(std::string, std::function<void(ValueType)>) [with ValueType = unsigned int]
Calls to MakeCallback which takes a parameter of type value_type also produce the same ambiguity error.
How can I resolve this without an explicit cast of registrar to the base class type?

Answer 1

I have a solution. All tat is needed is an extra level of indirection. In the Derived class I added a template function that dispatches to the correct base, as follows:
template< typename... Types >
class ConfigCallbackRegistrar : public BasicConfigCallbackRegistrar<Types>...
{
typedef ConfigCallbackRegistrar<Types...> type;
public:
/// #brief constructor
ConfigCallbackRegistrar() : BasicConfigCallbackRegistrar<Types>()...
{}
template<typename T>
type& Register( string nodePath,
typename BasicConfigCallbackRegistrar<T>::signature_type callback )
{
BasicConfigCallbackRegistrar<T>::RegisterCallback( std::move(nodePath),
std::move(callback) );
return *this;
}
};
The calling code becomes:
int main()
{
CallbackRegistrar registrar{};
registrar.Register<uint32_t>( "SomeNode", UintFtor() );
registrar.Register<string>( "SomeNode", StringFtor() );
return 0;
}