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 };

    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
    {
      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
    {
      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 ) );
      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 T* operator&() const
    {
      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)