Смешение двойной отправки и статического полиморфизма

Я уверен, что это плохая идея. Давайте представим, что у меня есть веская причина для этого. У меня есть дерево узлов, которое успешно использует статический полиморфизм для передачи сообщений. Важно отметить, что каждый узел не может типы узлов, к которым он подключается, он просто знает типы сообщений, которые он пропускает. Чтобы пройти по дереву, я реализовал шаблон посетителя, используя CRTP. Это работает для первого уровня дерева.

Однако при переходе ко второму слою дерева тип следующего узла стирается с использованием приведенного ниже класса AnyNode. Я не смог понять, как перейти от стертого типа к конкретному типу. Приведенный ниже пример работает в тестах, но я думаю, что он также, вероятно, действительно опасен и просто работает, если повезет с тем, где находится память.

Кажется проблематичным, что я должен стереть тип посетителя в AnyNode::Model<T>::acceptDispatch, который полностью известен в AnyNode::Concept::accept, Но я не могу понять, как перейти от Концепции к Модели. в Концепция (я попробовал ковариантный виртуальный cast функция, но это не сработало). И я не могу передать типизированный Visitor в производный класс Model с помощью виртуального метода, потому что виртуальные методы не могут быть шаблонизированы.

Есть ли безопасный способ позвонить node.accept и передать посетителю, не стирая тип посетителя, а затем статически вернуть его обратно? Есть ли способ понизить Концепцию до Model<T> во время выполнения? Есть ли лучший способ подойти к этой проблеме? Есть ли какой-нибудь сумасшедший новый способ решения C ++ 11, возможно, с помощью SFINAE?

class AnyNode
{
struct Concept
{
virtual ~Concept() = default;

template< typename V >
void accept( V & visitor )
{
acceptDispatch( &visitor );
}

virtual void acceptDispatch( VisitorBase * ) = 0;
};

template< typename T >
struct Model : public Concept
{
Model( T &n ) : node( n ) {}

void acceptDispatch( VisitorBase * v ) override
{
// dynamic cast doesn't work, probably for good reason
NodeVisitor< T >* visitor = static_cast< NodeVisitor< T >* >( v );
std::cout << "CAST" << std::endl;
if ( visitor ) {
std::cout << "WAHOO" << std::endl;
node.accept( *visitor );
}
}

private:
T &node;
};

std::unique_ptr< Concept > mConcept;
public:

template< typename T >
AnyNode( T &node ) :
mConcept( new Model< T >( node )) {}template< typename V >
void accept( V & visitor )
{
mConcept->accept( visitor );
}
};

РЕДАКТИРОВАТЬ Вот базовые классы посетителей и пример производного посетителя. Полученные посетители реализованы с помощью клиентского кода (это часть библиотеки), поэтому базовые классы не могут знать, какие посетители будут реализованы. Боюсь, это отвлекает от основного вопроса, но, надеюсь, поможет немного объяснить проблему. Здесь все работает, кроме случаев, когда ->accept( visitor ) вызывается по указателю AnyNode в outlet_visitor::operator(),

// Base class for anything that implements accept
class Visitable
{
public:
};// Base class for anything that implements visit
class VisitorBase
{
public:
virtual ~VisitorBase() = default;
};

// Visitor template class

template< typename... T >
class Visitor;

template< typename T >
class Visitor< T > : public VisitorBase
{
public:
virtual void visit( T & ) = 0;
};

template< typename T, typename... Ts >
class Visitor< T, Ts... > : public Visitor< Ts... >
{
public:
using Visitor< Ts... >::visit;

virtual void visit( T & ) = 0;
};

template< class ... T >
class NodeVisitor : public Visitor< T... >
{
public:

};

// Implementation of Visitable for nodes

template< class V >
class VisitableNode : public Visitable
{
template< typename T >
struct outlet_visitor
{
T &visitor;
outlet_visitor( T &v ) : visitor( v ) {}template< typename To >
void operator()( Outlet< To > &outlet )
{
for ( auto &inlet : outlet.connections()) {
auto n = inlet.get().node();
if ( n != nullptr ) {
// this is where the AnyNode is called, and where the
// main problem is
n->accept( visitor );
}
}
}
};

public:
VisitableNode()
{
auto &_this = static_cast< V & >( *this );
_this.each_in( [&]( auto &i ) {
// This is where the AnyNode is stored on the inlet,
// so it can be retrieved by the `outlet_visitor`
i.setNode( *this );
} );
}

template< typename T >
void accept( T &visitor )
{
auto &_this = static_cast< V & >( *this );
std::cout << "VISITING " << _this.getLabel() << std::endl;

visitor.visit( _this );

// The outlets are a tuple, so we use a templated visitor which
// each_out calls on each member of the tuple using compile-time
// recursion.
outlet_visitor< T > ov( visitor );
_this.each_out( ov );
}
};

// Example instantiation of `NodeVistor< T... >`

class V : public NodeVisitor< Int_IONode, IntString_IONode > {
public:

void visit( Int_IONode &n ) {
cout << "Int_IONode " << n.getLabel() << endl;
visited.push_back( n.getLabel());
}

void visit( IntString_IONode &n ) {
cout << "IntString_IONode " << n.getLabel() << endl;
visited.push_back( n.getLabel());
}

std::vector< std::string > visited;
};