Template for traversing tree node using boost :: variant

SOLUTION 1: SFINAE based technique

This decision is based on the fact that not being able to replace template parameters during template generation does not cause a compilation error (a replacement error is not an error): instead, this template is simply ignored when overloading is resolved. So, with some trick, you can choose which overloads of a particular function template should be visible depending on the template arguments provided at creation time.

When this method is used, it is important to ensure that the discriminatory conditions that determine the visibility of each congestion are mutually exclusive , or ambiguity may arise.

To begin with, you need to define some metaphase of traits that will help you determine if a particular class is a leaf:

// Primary template
template<typename T> struct is_leaf<T> { static const bool value = false; };

// Specializations...
template<> struct is_leaf<Leaf1> { static const bool value = true; };
template<> struct is_leaf<Leaf2> { static const bool value = true; };
...

      

        
        
        
      

    

Then you can use std::enable_if

(or boost::enable_if

if you are working with C ++ 98) to select which overload of the call operator should be visible:

class NodeVisitor: public boost::static_visitor<void>
{
public:

    // Based on the fact that boost::variant<> defines a type list called
    // "types", but any other way of detecting whether we are dealing with
    // a variant is OK
    template<typename Node>
    typename std::enable_if<
        !is_same<typename Node::types, void>::value 
        >::type 
    operator()(const Node& e) const
    {
        boost::apply_visitor( *this, e );
    }

    // Based on the fact that leaf classes define a static constant value
    // called "isLeaf", but any other way of detecting whether we are dealing
    // with a leaf is OK
    template<typename Leaf>
    typename std::enable_if<is_leaf<Leaf>::value>::type 
    operator()(const Leaf& e) const
    {
        ...
    }
};

      

        
        
        
      

    

If you are working in C ++ 98 and do not want to use boost::enable_if

as a replacement for std::enable_if

, an alternative approach is to use overload and unused argument resolution to distinguish between two helper function overloads.First of all, you define two dummy classes:

struct true_type { };
struct false_type { };

      

        
        
        
      

    

Then you'll re-create the meta-face is_leaf<>

, properly specializing in sheets:

// Primary template
template<typename T> struct is_leaf<T> { typedef false_type type; };

// Specializations...
template<> struct is_leaf<Leaf1> { typedef true_type type; };
template<> struct is_leaf<Leaf2> { typedef true_type type; };
...

      

        
        
        
      

    

Finally, you instantiate one of these dummy types to select the correct helper function overload process()

:

class NodeVisitor: public boost::static_visitor<void>
{
public:

    template<typename T>
    void operator()(const T& e) const
    {
        typedef typename is_leaf<T>::type helper;
        process(e, helper());
    }

    template<typename Node>
    void process(const Node& e, false_type) const
    {
        boost::apply_visitor(*this, e);
    }

    template<typename Leaf>
    void process(const Leaf& e, true_type) const
    {
        ...
    }
};