Clone.h

 
#pragma once
 
#if defined(Clone_RECURSES)
#error Recursive header files inclusion detected in Clone.h
#else // defined(Clone_RECURSES)
#define Clone_RECURSES
 
#if !defined Clone_h
#define Clone_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/base/CowPtr.h"
 
namespace DGtal
{
 
  // template class Clone
  template <typename T>
  class Clone
  {
    // ----------------------- Internal classes ------------------------------
  protected:
 
    enum Parameter { CONST_LEFT_VALUE_REF, LEFT_VALUE_REF, PTR, CONST_PTR,
                     COW_PTR, COUNTED_PTR, RIGHT_VALUE_REF, COUNTED_PTR_OR_PTR,
                     COUNTED_CONST_PTR_OR_CONST_PTR };
    void display( const std::string& method, Parameter p ) const
    {
      std::string sp;
      switch (p) {
      case CONST_LEFT_VALUE_REF: sp = "CONST_LEFT_VALUE_REF"; break;
      case LEFT_VALUE_REF:       sp = "LEFT_VALUE_REF"; break;
      case PTR:                  sp = "PTR"; break;
      case CONST_PTR:            sp = "CONST_PTR"; break;
      case COW_PTR:              sp = "COW_PTR"; break;
      case COUNTED_PTR:          sp = "COUNTED_PTR"; break;
      case RIGHT_VALUE_REF:      sp = "RIGHT_VALUE_REF"; break;
      case COUNTED_PTR_OR_PTR:   sp = "COUNTED_PTR_OR_PTR"; break;
      case COUNTED_CONST_PTR_OR_CONST_PTR: sp = "COUNTED_CONST_PTR_OR_CONST_PTR"; break;
      default:                   sp = "UNKNOWN"; break;
      }
      trace.info() << "[Clone<T>::" << method << " param="
                   << sp << "]" << std::endl;
        
    }
    struct TempPtr {
      inline TempPtr( T* ptr ) : _ptr( ptr ) {}
      inline ~TempPtr() { ASSERT( _ptr != 0 ); delete _ptr; }
      T* _ptr;
    };
 
    // ----------------------- Standard services ------------------------------
  public:
 
    inline ~Clone() {}
 
    inline Clone( const Clone & other )
      : myParam( other.myParam ), myPtr( other.myPtr ) {}
 
    inline Clone( const T & t )
      : myParam( CONST_LEFT_VALUE_REF ), myPtr( static_cast<const void*>( &t ) ) {}
 
    inline Clone( T* ptrT )
      : myParam( PTR ), myPtr( static_cast<const void*>( ptrT ) ) {}
 
    inline Clone( const CowPtr<T> & ptrT )
      : myParam( COW_PTR ), myPtr( static_cast<const void*>( &ptrT ) ) {}
 
    inline Clone( const CountedPtr<T> & ptrT )
      : myParam( COUNTED_PTR ), myPtr( static_cast<const void*>( &ptrT ) ) {}
 
    inline Clone( T && t )
      : myParam( RIGHT_VALUE_REF ), myPtr( static_cast<const void*>( &t ) ) {}
 
 
    inline operator T() const
    {
      // display( "operator T() const", myParam );
      switch( myParam ) {
      case CONST_LEFT_VALUE_REF:
        return T( * static_cast< const T* >( myPtr ) );
      case PTR: {
        TempPtr tmp( const_cast< T* >( static_cast< const T* >( myPtr ) ) );
        return T( * static_cast< const T* >( myPtr ) );
      } // destroy acquired pointer.
      case COW_PTR:
        return T( * static_cast< const CowPtr<T>* >( myPtr )->get() );
      case COUNTED_PTR:
        return T( * static_cast< const CountedPtr<T>* >( myPtr )->get() );
      case RIGHT_VALUE_REF:
        return T( std::move( * const_cast<T*>( static_cast< const T* >( myPtr ) ) ) );
      default: ASSERT( false && "[Clone::operator T() const] Invalid cast for given type. " );
        return T( * static_cast< const T* >( myPtr ) );
      }
    }
 
    inline operator CowPtr<T>() const
    {
      // display( "operator CowPtr<T>() const", myParam );
      switch( myParam ) {
      case CONST_LEFT_VALUE_REF:
        return CowPtr<T>( new T( * static_cast< const T* >( myPtr ) ) );
      case PTR:
        return CowPtr<T>( const_cast<T*>( static_cast< const T* >( myPtr ) ) );
      case COW_PTR:
        return CowPtr<T>( * static_cast< const CowPtr<T>* >( myPtr ) );
      case COUNTED_PTR:
        return CowPtr<T>( * static_cast< const CountedPtr<T>* >( myPtr ), true );
      case RIGHT_VALUE_REF:
        return CowPtr<T>( new T( std::move( * const_cast<T*>( static_cast< const T* >( myPtr ) ) ) ) );
      default: ASSERT( false && "[Clone::operator CowPtr<T>() const] Invalid cast for given type. " );
        return CowPtr<T>( 0 );
      }
    }
 
    inline operator CountedPtr<T>() const
    {
      // display( "operator CountedPtr<T>() const", myParam );
      switch( myParam ) {
      case CONST_LEFT_VALUE_REF:
        return CountedPtr<T>( new T( * static_cast< const T* >( myPtr ) ) );
      case PTR:
        return CountedPtr<T>( const_cast<T*>( static_cast< const T* >( myPtr ) ) );
      case COW_PTR:
        return CountedPtr<T>( new T( * static_cast< const CowPtr<T>* >( myPtr )->get() ) );
      case COUNTED_PTR:
        return CountedPtr<T>( * static_cast< const CountedPtr<T>* >( myPtr ) );
      case RIGHT_VALUE_REF:
        return CountedPtr<T>( new T( std::move( * const_cast<T*>( static_cast< const T* >( myPtr ) ) ) ) );
      default: ASSERT( false && "[Clone::operator CountedPtr<T>() const] Invalid cast for given type. " );
        return CountedPtr<T>( 0 );
      }
    }
 
    inline T* operator&() const
    {
      // display( "T* operator &() const", myParam );
      switch( myParam ) {
      case CONST_LEFT_VALUE_REF:
        return new T( * static_cast< const T* >( myPtr ) );
      case PTR:
        return const_cast<T*>( static_cast< const T* >( myPtr ) );
      case COW_PTR:
        return new T( *( static_cast< const CowPtr<T>* >( myPtr )->get() ) );
      case COUNTED_PTR:
        return new T( *( static_cast< const CountedPtr<T>* >( myPtr )->get() ) );
      case RIGHT_VALUE_REF:
        return new T( std::move( * const_cast<T*>( static_cast< const T* >( myPtr ) ) ) );
      default: ASSERT( false && "[T* Clone::operator&() const] Invalid address for given type. " );
        return 0;
      }
    }
 
    // ------------------------- Private Datas --------------------------------
  private:
    const Parameter myParam;
    const void* const myPtr;
 
 
    // ------------------------- Hidden services ------------------------------
  private:
 
    Clone();
 
 
    Clone & operator= ( const Clone & other );
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class Clone
 
} // namespace DGtal
 
 
// Includes inline functions.
 
//                                                                           //
 
#endif // !defined Clone_h
 
#undef Clone_RECURSES
#endif // else defined(Clone_RECURSES)