ConstAlias.h

 
#pragma once
 
#if defined(ConstAlias_RECURSES)
#error Recursive header files inclusion detected in ConstAlias.h
#else // defined(ConstAlias_RECURSES)
#define ConstAlias_RECURSES
 
#if !defined ConstAlias_h
#define ConstAlias_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/base/CountedPtrOrPtr.h"
#include "DGtal/base/CowPtr.h"
#include "DGtal/base/CountedConstPtrOrConstPtr.h"
 
namespace DGtal
{
 
  // template class ConstAlias
  template <typename T>
  class ConstAlias
  {
 
    // ----------------------- 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:
 
    ConstAlias( const ConstAlias & other ) = default;
 
    inline ~ConstAlias() {}
 
    inline ConstAlias( const T& t )
      : myParam( CONST_LEFT_VALUE_REF ), myPtr( static_cast<const void*>( &t ) ) {}
 
    inline ConstAlias( const T* ptrT )
      : myParam( CONST_PTR ), myPtr( static_cast<const void*>( ptrT ) ) {}
 
 
    ConstAlias( const CowPtr<T>& ) = delete;
 
 
    inline ConstAlias( const CountedPtr<T>& shT )
      : myParam( COUNTED_PTR ), myPtr( static_cast<const void*>( &shT ) ) {}
 
    inline ConstAlias( const CountedPtrOrPtr<T>& shT )
      : myParam( COUNTED_PTR_OR_PTR ), myPtr( static_cast<const void*>( &shT ) ) {}
 
    inline ConstAlias( const CountedConstPtrOrConstPtr<T>& shT )
      : myParam( COUNTED_CONST_PTR_OR_CONST_PTR ), myPtr( static_cast<const void*>( &shT ) ) {}
 
    ConstAlias( T&& ) = delete;
 
    inline operator const T&() const
      {
        switch( myParam ) {
          case CONST_LEFT_VALUE_REF:
          case CONST_PTR:
            return *( static_cast< const T* >( myPtr ) );
          default: ASSERT( false && "[ConstAlias::operator const T&() const] Invalid cast for given type. Consider passing a const left-value reference or a const pointer as a parameter." );
                   return *( static_cast< const T* >( myPtr ) );
        }
      }
 
    inline const T* operator&() const
      {
        switch( myParam ) {
          case CONST_LEFT_VALUE_REF:
          case CONST_PTR:
            return static_cast< const T* >( myPtr );
          default: ASSERT( false && "[const T* ConstAlias::operator&() const] Invalid address operator for given type. Consider passing a const left-value reference or a const pointer as a parameter." );
                   return static_cast< const T* >( myPtr );
        }
    }
 
    inline operator CountedConstPtrOrConstPtr<T>() const
      {
        switch( myParam ) {
          case CONST_LEFT_VALUE_REF:
          case CONST_PTR:
            return CountedConstPtrOrConstPtr<T>( static_cast< const T* >( myPtr ), false );
          case COUNTED_PTR:
            return CountedConstPtrOrConstPtr<T>( *( static_cast< const CountedPtr<T>* >( myPtr ) ) );
          case COUNTED_PTR_OR_PTR:
            return CountedConstPtrOrConstPtr<T>( *( static_cast< const CountedPtrOrPtr<T>* >( myPtr ) ) );
          case COUNTED_CONST_PTR_OR_CONST_PTR:
            return CountedConstPtrOrConstPtr<T>( *( static_cast< const CountedPtrOrPtr<T>* >( myPtr ) ) );
          default: ASSERT( false && "[ConstAlias::operator CowPtr<T>() const] Invalid cast for given type. Consider passing a CountedPtr or a CowPtr as a parameter." );
                   return CountedConstPtrOrConstPtr<T>( 0, false );
        }
    }
 
    inline const T* operator->() const
      {
        switch( myParam ) {
          case CONST_LEFT_VALUE_REF:
          case CONST_PTR:
            return static_cast< const T* >( myPtr );
          case COUNTED_PTR:
            return ( static_cast< const CountedPtr<T>* >( myPtr ) )->operator->();
          case COUNTED_PTR_OR_PTR:
            return ( static_cast< const CountedPtrOrPtr<T>* >( myPtr ) )->operator->();
          case COUNTED_CONST_PTR_OR_CONST_PTR:
            return ( static_cast< const CountedConstPtrOrConstPtr<T>* >( myPtr ) )->operator->();
          default: ASSERT( false && "[ConstAlias::operator->() const] Invalid cast for given type. Consider passing a CountedPtr or a CowPtr as a parameter." );
                   return 0;
      }
    }
 
    // ------------------------- Private Datas --------------------------------
  private:
    const Parameter myParam;
    const void* const myPtr;
 
 
    // ------------------------- Internals ------------------------------------
  private:
 
    ConstAlias & operator= ( const ConstAlias & other );
 
  }; // end of class ConstAlias
 
} // namespace DGtal
 
 
// Includes inline functions.
 
//                                                                           //
 
#endif // !defined ConstAlias_h
 
#undef ConstAlias_RECURSES
#endif // else defined(ConstAlias_RECURSES)