How to use dynamic cast with variadics? - c++

Question

I have a working functor_wrapper class for 2 parameters that I'm having trouble generalising into variadic template parameters.
In particular, I'm having trouble getting the syntax right while converting this line in 2 parameters to variadics:
2 Parameter CODE
return m_cb( dynamic_cast<T const&>( t ), dynamic_cast<U const&>( u ));
Broken Variadic CODE
return m_cb( dynamic_cast<I const&>( t ),
dynamic_cast<typename... const& Cs>( u... ));
For anyone who wants to know, this wrapper class is part of a multiple_dispatch class. In order to provide a common type/interface to the client, I have this Functor_Wrapper class and operator() that takes the parent class type. When dispatching, I downcast by dynamic_cast<>ing the parameters down to the correct types.
UPDATE
I just realised that I have another problem: my virtual operator() in my Parent_Functor_Wrapper needs to be converted to n parameters of P const& so I need to unroll the signature somehow!
The same applies to the concrete implementation of operator() in Functor_Wrapper.
UPDATE 2
Posting complete code so the programming context can be better understood.
UPDATE 3
Accepting ildjam's answer because it addresses the original problem. I need to think some more about how to deal with the pure virtual operator(). Meanwhile, the code below works fine if you comment out #define USE_VARIADICS, and run the hard-coded version. I will post a separate question if I cannot resolve this issue.
CODE
#include <typeinfo>
#include <functional>
#include <stdexcept>
#include <cassert>
#include <map>
#include <array>
#include <iostream>
#define USE_VARIADICS
#ifdef USE_VARIADICS
template<typename P,typename R,typename... Cs>
struct Parent_Functor_Wrapper
{
using cb_func = std::function<R(P const&, P const& )>;
virtual R operator()( P const&, P const& ) = 0;
};
// parent class, return type, concrete classes...
template<typename P,typename R,typename I,typename... Cs>
struct Functor_Wrapper :
public Parent_Functor_Wrapper<P,R,Cs...>
{
using cb_func = std::function<R(I const&, Cs const& ...)>;
cb_func m_cb;
// dynamic_cast<typename... const& Cs>( u... ) -> dynamic_cast<Cs const&>(u)...
Functor_Wrapper( cb_func cb ) : m_cb( cb ) { }
virtual R operator()( P const& t, Cs const& ... u ) override
{
return m_cb( dynamic_cast<I const&>( t ),
dynamic_cast<Cs const&>( u )...);
}
};
#else
template<typename P,typename R>
struct Parent_Functor_Wrapper
{
using cb_func = std::function<R(P const&, P const& )>;
virtual R operator()( P const&, P const& ) = 0;
};
template<typename P,typename R,typename T,typename U>
struct Functor_Wrapper :
public Parent_Functor_Wrapper<P,R>
{
using cb_func = std::function<R(T const&, U const&)>;
cb_func m_cb;
Functor_Wrapper( cb_func cb ) : m_cb( cb ) { }
virtual R operator()( P const& t, P const& u ) override
{
return m_cb( dynamic_cast<T const&>( t ), dynamic_cast<U const&>( u ));
}
};
#endif
template<typename T,unsigned N>
struct n_dimension
{
using type = typename n_dimension<T,N-1>::type;
};
template<typename T>
struct n_dimension<T,1>
{
using type = std::tuple<T>;
};
template<typename K>
K gen_key( K* p=nullptr, size_t idx=0 )
{
return *p;
};
template<typename K,typename T,typename... Ts>
K gen_key( K* p=nullptr, size_t idx=0 )
{
K m_instance;
if ( p==nullptr )
p = &m_instance;
*(p->begin() + idx) = typeid( T ).hash_code();
gen_key<K,Ts...>( p, ++idx );
return m_instance;
};
template<typename F,typename P,typename... Cs>
struct multiple_dispatcher { multiple_dispatcher() { } };
template<typename F,typename P,typename I,typename... Cs>
struct multiple_dispatcher<F,P,I,Cs...>
{
using functor_type = Parent_Functor_Wrapper<P,std::string>;
using key_type = std::array<size_t,F::n_dimension::val>;
using map_type = std::map<key_type,functor_type*>;
using value_type = typename map_type::value_type;
map_type m_jump_table;
multiple_dispatcher( std::initializer_list<value_type> const& cb_mapping )
{
for( const auto& p : cb_mapping )
m_jump_table.insert( p );
}
template< typename T, typename U >
typename F::return_type operator()( T& x, U& y )
{
auto k = key_type{ { x.get_id(), y.get_id() } };
auto func = m_jump_table.at( k );
return (*func)( x, y );
}
size_t size() const { return m_jump_table.size(); }
};
// =============================================================================
struct A { virtual ~A() { }
virtual size_t get_id() const { return typeid( A ).hash_code(); }
};
struct B : public A { virtual ~B() { }
virtual size_t get_id() const override { return typeid( B ).hash_code(); }
};
struct C : public A { int x; virtual ~C() { }
virtual size_t get_id() const override { return typeid( C ).hash_code(); }
};
struct Functor_Pairs
{
using return_type = std::string;
enum n_dimension { val = 2 };
static std::string MyFn(A const& arg1, A const& arg2) { return "A,A"; }
static std::string MyFn(A const& arg1, B const& arg2) { return "A,B"; }
static std::string MyFn(A const& arg1, C const& arg2) { return "A,C"; }
static std::string MyFn(B const& arg1, A const& arg2) { return "B,A"; }
static std::string MyFn(B const& arg1, B const& arg2) { return "B,B"; }
static std::string MyFn(B const& arg1, C const& arg2) { return "B,C"; }
static std::string MyFn(C const& arg1, A const& arg2) { return "C,A"; }
static std::string MyFn(C const& arg1, B const& arg2) { return "C,B"; }
static std::string MyFn(C const& arg1, C const& arg2) { return "C,C"; }
};
// =============================================================================
std::string (*MyFun_aa)(A const&, A const&) = &Functor_Pairs::MyFn;
std::string (*MyFun_ab)(A const&, B const&) = &Functor_Pairs::MyFn;
std::string (*MyFun_ac)(A const&, C const&) = &Functor_Pairs::MyFn;
std::string (*MyFun_ba)(B const&, A const&) = &Functor_Pairs::MyFn;
std::string (*MyFun_bb)(B const&, B const&) = &Functor_Pairs::MyFn;
std::string (*MyFun_bc)(B const&, C const&) = &Functor_Pairs::MyFn;
std::string (*MyFun_ca)(C const&, A const&) = &Functor_Pairs::MyFn;
std::string (*MyFun_cb)(C const&, B const&) = &Functor_Pairs::MyFn;
std::string (*MyFun_cc)(C const&, C const&) = &Functor_Pairs::MyFn;
Functor_Wrapper<A,std::string,A,A> w_aa( MyFun_aa );
Functor_Wrapper<A,std::string,A,B> w_ab( MyFun_ab );
Functor_Wrapper<A,std::string,A,C> w_ac( MyFun_ac );
Functor_Wrapper<A,std::string,B,A> w_ba( MyFun_ba );
Functor_Wrapper<A,std::string,B,B> w_bb( MyFun_bb );
Functor_Wrapper<A,std::string,B,C> w_bc( MyFun_bc );
Functor_Wrapper<A,std::string,C,A> w_ca( MyFun_ca );
Functor_Wrapper<A,std::string,C,B> w_cb( MyFun_cb );
Functor_Wrapper<A,std::string,C,C> w_cc( MyFun_cc );
// =============================================================================
int main( int argc, char* argv[] )
{
B b;
C c;
A& arg1 = b;
A& arg2 = c;
using md_type = multiple_dispatcher<Functor_Pairs,A,B,C>;
using K = md_type::key_type;
md_type md
{
std::make_pair( gen_key<K,A,A>(), &w_aa ),
std::make_pair( gen_key<K,A,B>(), &w_ab ),
std::make_pair( gen_key<K,A,C>(), &w_ac ),
std::make_pair( gen_key<K,B,A>(), &w_ba ),
std::make_pair( gen_key<K,B,B>(), &w_bb ),
std::make_pair( gen_key<K,B,C>(), &w_bc ),
std::make_pair( gen_key<K,C,A>(), &w_ca ),
std::make_pair( gen_key<K,C,B>(), &w_cb ),
std::make_pair( gen_key<K,C,C>(), &w_cc )
};
std::cerr << "N = " << md.size() << std::endl;
std::cerr << "RESULT = " << md( arg1, arg2 ) << std::endl;
assert( !std::string( "B,C" ).compare( md( arg1, arg2 )) );
#if 0
std::cerr << typeid( A ).hash_code() << std::endl;
std::cerr << typeid( B ).hash_code() << std::endl;
std::cerr << typeid( C ).hash_code() << std::endl;
#endif
return 0;
}

Answer 1

You need to change:
dynamic_cast<typename... const& Cs>( u... )
to:
dynamic_cast<Cs const&>( u )...
The former (invalid syntax aside) is attempting to expand Cs into a single dynamic_cast while the latter expands each type in Cs into its own dynamic_cast.
That being said, I don't think your override will work since your base's operator() signature is R operator()( P const&, P const& ) and your derived's signature is not (unless Cs const&... coincidentally happens to expand into P const&)…