// needed for is_same
#include <type_traits>
#include <tuple>
#include <iostream>
using namespace std;
// this should be an inner and private metafunction of exists_type
// I put here for clarity
template<typename T, typename Tuple, const int index>
struct exists_type_index
{
static const bool value =
is_same < T, typename tuple_element<index, Tuple>::type >::value ||
exists_type_index<T, Tuple, index-1>::value;
};
// stop the recursion when reach the first element
template<typename T, typename Tuple>
struct exists_type_index<T, Tuple, 0>
{
static const bool value = is_same < T, typename tuple_element<0, Tuple>::type >::value;
};
// exists_type metafunction (clients call this)
template<typename T, typename Tuple>
struct exists_type
{
static const bool value = exists_type_index<T, Tuple, tuple_size<Tuple>::value-1>::value;
};
////////////////////////// Executor
template<bool b>
struct Executor
{
template<typename T>
static void execute(T&&)
{
cout << "General case" << endl;
}
};
template<>
struct Executor <true>
{
template<typename T>
static void execute(T&&)
{
cout << "Specific case" << endl;
}
};
// clients call this
template<typename Tuple>
struct MultiTypeDispatcher
{
template<typename T>
void function( T&& t )
{
Executor<exists_type<T, Tuple>::value>::execute(forward<T>(t));
}
};
int main()
{
MultiTypeDispatcher< tuple<int, float, string> > dispatcher;
dispatcher.function(string("hello!")); // Specific case!
dispatcher.function(1.0f); // Specific case!
dispatcher.function(1.0); // General case!
return 0;
}
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