Tiny Template Library: variant

The variant pseudo-code looks like this:

template < typename T1, typename T2, ... > 
struct variant
{
    //list of user types
    typedef meta::typelist< T1, T2,...> types;
    
    //initialization 
    variant() : p_(0) {}
    
    template< typename T >
    variant( const T& d ) : p_(0) 
    {
        //find the index of this type in the variant typelist
        which_ = find_type<T>::value;
        //in place construction
        p_ = new(buffer_) data_holder<T>(d);
    }
    
    virtual ~variant() { destroy(); }
    
    inline int which() const { return which_; }
    
    inline bool is_valid() const { return p_ != 0; }
    
    void destroy() 
    { 
        if(!is_valid()) return;
        p_->~data_holder_base(); 
        p_ = 0;
    }
    
private:
    
    //data_holder is a wrapper for the user types
    
    struct data_holder_base 
    { 
        virtual ~data_holder_base() {}
    };
    
    temlate< typename T >
    struct data_holder : data_holder_base
    {
        T d_;
        data_holder( const T& d ) : d_(d) {}
    };
    
    //list of data holder types
    typedef meta::typelist<data_holder<T1>, data_holder<T2>,...> holder_types;
    
    //reserve enough space to hold the largest type
    char buffer_[find_largest_type<holder_types>::value];


    
    //pointer to the controlled object
    data_holder_base *p_;
    
    //object type index
    int which_;
};

Using variant

typedef variant<int, double> my_variant;

void f( my_variant& v )
{
    int n;
    double x;
    switch( v.which() )
    {
    case 0:  //int variable
        n = get<int>(v);
        //do something with int;
        break;
        
    case 1:  //double variable
        x = get<double>(v);
        //do something with the double;
        break;
    }
};

As you can see, the get<> function can be used to retrieve the typed data from variant<>. Obviously this switch statement is ugly and not very flexible. The function f() has to know the type indexes in my_variant. One way to solve these problems is to utilize the Gof visitor pattern ideas.

typedef variant<int, double> my_variant;

struct visitor
{
    void operator()(int n)
    {
    //do something with the int;
    ...
    }
    void operator()(double x)
    {
    //do something with the double;
    ...
    }
    
    //ignore any other types
    template< typename T >
    void operator()( T d )
    {
    }
};

my_variant var;
visitor vis;
apply_visitor(var, vis);

I think that it looks much nicer and we don't have to worry about type indexes or any other type identifiers for the same matter. The apply_visitor() function is implemented in TTL. apply_visitor does the following:

Another interesting implementation of variant is event dispatching. Suppose we have an event source that can generate multiple event types. For the simplicity sake, the event types are int and double.  We can define the event type as following:

typedef variant< int, double > event;

typedef function< void (event&) > callback;

typedef variant< int, double > event;
typedef function< void (event&) > callback;

struct event_source
{
    callback cb_

    event_source( callback& cb ) : cb_(cb) {}

    void do_something()
    {
        event ev;

        ...
        //generate int event
        ev = 1;
        cb_( ev );

        ....
        //generate double event
        ev = 2.3;
        cb_( ev );
    }
};

//define our event vistor
struct event_visitor
{
    //process int event
    void operator()(int n)
    { 
        cout << "got int:" << n;
    }
    
    //process double event
    void operator()(double n)
    { 
        cout << "got double:" << n;
    }
    
    //ignore any other events
    template< typename T >
    void operator()( T d )
    {
    }
}

void my_callback( event& e )
{
    event_visitor vistor;
    apply_visitor(e, vistor);
}

main()
{
    event_source src(my_callback);
    src.do_something();
}