/www/proggenOrg/dedupe/export/trunk/dataholding/datavariant.h

Go to the documentation of this file.

#ifndef ORG_PROGGEN_DEDUPE_DATAHOLDING_DATAVARIANT_H
#define ORG_PROGGEN_DEDUPE_DATAHOLDING_DATAVARIANT_H

#include <typeinfo>
#include <string>
#include <iostream>

namespace Dedupe
{
  namespace Dataholding
  {
    namespace Variant
    {
      class Data
      {
        public:
        virtual const std::type_info & GetType() const = 0;
        virtual ~Data() {} ;
      };

      template<class T> class DataVariant : public Data
      {
        T HoldedData;

        public:

        DataVariant( T data ) : HoldedData( data ) {};

        virtual const std::type_info & GetType() const
        {
          const std::type_info &ti = typeid( HoldedData );

          return ti;
        }

        T GetData() const
        {
          return HoldedData;
        }

        DataVariant( const DataVariant& origin )
        : HoldedData( origin.HoldedData ) {}

        DataVariant& operator=( const DataVariant& origin)
        {
          if( this == &origin ) return *this;
          HoldedData = origin.HoldedData;
          return *this;
        }

      };

      enum CastResults
      {
        CastOK,             
        DifferentDatatypes, 
        CouldNotCast,       
        BadCastException,   
        NULLPointerGiven    
      };

      template<class T> CastResults CastDataVariant( Data *incoming, T &returning )
      {
        //Make sure, the incoming pointer is not NULL
        if( incoming == NULL ) return NULLPointerGiven;

        /*Make sure, holded data and the
          returning variable are frome the same type
        */
        if( incoming->GetType() != typeid( T ) ) return DifferentDatatypes;

        //Define the pointer here, cause the cast is in a different scope
        DataVariant<T> *ptr = NULL;

        //catch bad_cast exceptions and return an BadCastExecption error
        try
        {
          ptr = dynamic_cast
          <Dedupe::Dataholding::Variant::DataVariant<T> *>(incoming);
        }
        catch (std::bad_cast& bc)
        {
          return BadCastException;
        }

        if( ptr == NULL ) return CouldNotCast;
        //write the data to the returning varible
        returning = ptr->GetData();

        return CastOK;
      }
    }
  }
}
#endif