static void visit( const Key&, test::containers& p, visitor& v )
 {
     v.apply( "pair", p.pair );
     v.apply( "vector", p.vector );
     v.apply( "set", p.set );
     v.apply( "map", p.map );
 }

std::size_t visitor_hasher::hash(const visitor& v) {
    std::size_t seed(0);

    combine(seed, dynamic_cast<const dogen::yarn::element&>(v));

    combine(seed, hash_std_list_dogen_yarn_name(v.visits()));
    combine(seed, hash_boost_optional_dogen_yarn_name(v.parent()));

    return seed;
}

void  variant::visit( const visitor& v )const
{
    switch( get_type() )
    {
    case null_type:
        v.handle();
        return;
    case int64_type:
        v.handle( *reinterpret_cast<const int64_t*>(this) );
        return;
    case uint64_type:
        v.handle( *reinterpret_cast<const uint64_t*>(this) );
        return;
    case double_type:
        v.handle( *reinterpret_cast<const double*>(this) );
        return;
    case bool_type:
        v.handle( *reinterpret_cast<const bool*>(this) );
        return;
    case string_type:
        v.handle( **reinterpret_cast<const const_string_ptr*>(this) );
        return;
    case array_type:
        v.handle( **reinterpret_cast<const const_variants_ptr*>(this) );
        return;
    case object_type:
        v.handle( **reinterpret_cast<const const_variant_object_ptr*>(this) );
        return;
    default:
        FC_THROW_EXCEPTION( assert_exception, "Invalid Type / Corrupted Memory" );
    }
}

 void fltvar     ::invite (visitor &v) { v.visit (*this); }

void recall::accept(visitor& v)
{
	v.visit_recall(shared_from_this());
}

void attack::accept(visitor& v)
{
	v.visit(shared_from_this());
}

/* virtual */ void
group::visit ( visitor const& v )
{
  v.accept(*this);
  std::for_each(begin(), end(), std::bind(&node::visit, std::placeholders::_1, std::ref(v)));
}

void recruit::accept(visitor& v)
{
	v.visit(shared_from_this());
}

void move::accept(visitor& v)
{
	v.visit(shared_from_this());
}

 virtual void visit(visitor& v) override 
 {
     v.accept(*this);
 }

void
othr_decl_n::accept (visitor & v) 
{
  v.visit_othr_decl (this);
}

 void instruction::invite (visitor &v) { v.visit (*this); }