Alias.h

#pragma once

#if defined(Alias_RECURSES)
#error Recursive header files inclusion detected in Alias.h
#else // defined(Alias_RECURSES)

#define Alias_RECURSES

#if !defined Alias_h

#define Alias_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/base/CowPtr.h"

namespace DGtal
{

  // template class Alias
  template <typename T>
  class Alias
  {

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

    // ----------------------- Standard services ------------------------------
  public:

    inline ~Alias() {}

    Alias( const T& ) = delete;

    Alias( const T* ) = delete;

    inline Alias( T& t )
      : myParam( LEFT_VALUE_REF ), myPtr( static_cast<const void*>( &t ) )
      {}

    inline Alias( T* t )
      : myParam( PTR ), myPtr( static_cast<const void*>( t ) ) {}

    Alias( const CowPtr<T>& ) = delete;

    inline Alias( const CountedPtr<T>& t )
      : myParam( COUNTED_PTR ), myPtr( static_cast<const void*>( &t ) )
      {}

    inline Alias( const CountedPtrOrPtr<T>& t )
      : myParam( COUNTED_PTR_OR_PTR ), myPtr( static_cast<const void*>( &t ) )
      {}

    Alias( T&& ) = delete;

    inline operator T&() const
      {
        switch( myParam ) {
          case LEFT_VALUE_REF:
          case PTR:
            return *( const_cast< T* >( static_cast< const T* >( myPtr ) ) );
          default: ASSERT( false && "[Alias::operator T&() const] Invalid cast for given type. Consider passing a left-value reference or a pointer as a parameter." );
                   return *( const_cast< T* >( static_cast< const T* >( myPtr ) ) );
        }
    }

    inline T* operator&() const
      {
        switch( myParam ) {
          case LEFT_VALUE_REF:
          case PTR:
            return const_cast< T* >( static_cast< const T* >( myPtr ) );
          default: ASSERT( false && "[T* Alias::operator&() const] Invalid address operator for given type. Consider passing a left-value reference or a pointer as a parameter." );
                   return const_cast< T* >( static_cast< const T* >( myPtr ) );
        }
    }

    inline operator CountedPtrOrPtr<T>() const
      {
        switch( myParam ) {
          case LEFT_VALUE_REF:
          case PTR:
            return CountedPtrOrPtr<T>( const_cast< T* >( static_cast< const T* >( myPtr ) ), false );
          case COUNTED_PTR:
            return CountedPtrOrPtr<T>( *( static_cast< const CountedPtr<T>* >( myPtr ) ) );
          case COUNTED_PTR_OR_PTR:
            return CountedPtrOrPtr<T>( *( static_cast< const CountedPtrOrPtr<T>* >( myPtr ) ) );
          default: ASSERT( false && "[Alias::operator CountedPtrOrPtr<T>() const] Invalid cast for given type. Consider passing a reference, a pointer or a CountedPtr as a parameter." );
                   return CountedPtrOrPtr<T>( 0 );
        }
    }

    // ------------------------- Private Datas --------------------------------
  private:
    const Parameter myParam;
    const void* const myPtr;


    // ------------------------- Internals ------------------------------------
  private:

    Alias & operator= ( const Alias & other );

  }; // end of class Alias

} // namespace DGtal


// Includes inline functions.

//                                                                           //

#endif // !defined Alias_h

#undef Alias_RECURSES
#endif // else defined(Alias_RECURSES)