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:
 
    Alias( const Alias & other ) = default;
 
    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)