---

d_Variant.h

Go to the documentation of this file.

#ifndef d_Variant_h
#define d_Variant_h 1
//------------------------------------------------------------------------------
#include <iostream>

#include "oLibrary.h"

//------------------------------------------------------------------------------
class _ODLL d_Variant
{
  public :
    d_Variant() : data(0) {}

    d_Variant( const d_Variant & rhs )
    {
      if( rhs.data )
        rhs.data->AddRef();
      data = rhs.data;
    }

    ~d_Variant()
    {
      if( data )
        data->Release();
    }
 
    // NOTE: This code takes care of self-asignment.
    // DO NOT CHANGE THE ORDER of the statements.
    d_Variant& operator = ( const d_Variant& rhs )
    {
      if( rhs.data )
        rhs.data->AddRef();
      if( data )
        data->Release();
      data = rhs.data;
      return *this;
    }

    // This member template constructor allows you to
    // instance a d_Variant object with a value of any type.
    template<typename T> d_Variant ( T v )
      : data ( new Impl<T>(v) )
      { data->AddRef() ; }

    // This generic conversion operator let you retrieve
    // the value held.
    // To avoid template specialization conflicts, it
    // returns an instance of type T, which will be a COPY
    // of the value contained.
    template<typename T> operator T () const
      { return CastFromBase<T>( data )->data ; }

    // With expressions of the form: int a = my_variant ,
    // the compiler needs to take the template argument T
    // from the type of the left side of the assigment.
    // Most compilers won't do that, so you might need this
    // non-operator form, as in:
    // int a = my_variant.get<int>();
    // This forms returns a REFERENCE and not a COPY, which
    // will be significant in some cases.
    template<typename T> const T& get() const
      { return CastFromBase<T>( data )->data ; }

    char* raw() const;

    // This method can be used to test if this d_Variant
    // holds a value of type T. It takes no arguments,
    // so it can only be used with a explicit template
    // instancing:
    //   d_Variant var(3) ; if ( var.is_type<int>() ) ...
    template<typename T> bool is_type() const
      { return typeid(*data)==typeid(Impl<T>); }

    // This method can be used to test if this d_Variant
    // holds a value of type T.
    // It takes one argument, so it can be used with
    // a test variable of the desired type:
    //   int n=3; d_Variant var(n) ;
    //   if ( var.is_type(n) ) ...
    template<typename T> bool is_type(T v) const
      { return typeid(*data)==typeid(v); }

  private :

    // This base class provides polymorphism to Impl<>, due
    // to the virtual destructor.
    // It implements the reference counting over Impl<>.
    struct ImplBase
    {
      ImplBase() : refs ( 0 ) {}
      virtual ~ImplBase() {}
      void AddRef () { refs ++ ; }
      void Release() { refs -- ;
                       if ( refs == 0 )
                         delete this ;
                     }
      size_t refs ;
    } ;

    // An instance of Impl<T> is just a straight copy of a
    // value of type T, but re-typed as a polymorphic type.
    // As long as the copy constructor for T is properly
    // implemented, the value will be properly copied.
    template<typename T>
    struct Impl : ImplBase
    {
       Impl ( T v ) : data ( v ) {}
      ~Impl () {}
      T data ;
    } ;

    // The following 2 methods are static because they don't
    // operate on d_Variant instances.
    template<typename T>
    static ImplBase* CastToBase ( Impl<T>* v )
      { return v ; } // Implicit convertion here

    template<typename T>
    static Impl<T>* CastFromBase ( ImplBase* v )
    {
      // This upcast will fail if T is other than the T used
      // with the constructor of d_Variant.
      Impl<T>* p = dynamic_cast<Impl<T>*> ( v ) ;
      if ( p == 0 )
        throw invalid_argument
         ( typeid(T).name()+string(" is not a valid type"));
      return p ;
    }

    ImplBase* data;
};

//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

---