GloTOndemand.h

gehe zur Dokumentation dieser Datei

#ifndef INC_GLOTONDEMAND_H
#define INC_GLOTONDEMAND_H
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#include "GloTypes.h"
#include "GloReference.h"
#include "GloBase.h"
#include "GloObjID.h"
#include "GloBasePersistent.h"
#include "EuException.h"
#include "memory"
//-----------------------------------------------------------------------------
namespace glo
{
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  template <typename Base, typename Derived>
  class IsBaseClassOf
  {
    private:
      //-----------------------------------------------------------------------
      typedef char Yes;
      //-----------------------------------------------------------------------
      struct No { char dummy[2]; };
      //-----------------------------------------------------------------------
      static Yes Test( Base * );
      //-----------------------------------------------------------------------
      static No Test(...);
      //-----------------------------------------------------------------------
      template <typename T> struct IsClass
      {
        typedef char Yes[1];
        typedef char No[2];
 
        template <typename U> static Yes & Test( void( U::* )() );
        template <typename U> static No & Test(...);
 
        static const bool value = sizeof( Test<T>( 0 ) ) == sizeof( Yes );
      };
      template <typename T> struct IsClass {…};
      //-----------------------------------------------------------------------
 
    public:
      //-----------------------------------------------------------------------
      static const bool value = IsClass<Base>::value
                                && IsClass<Derived>::value
                                && sizeof( Test( static_cast<Derived*>( 0 ) ) ) == sizeof(Yes);
  };
  class IsBaseClassOf {…};
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  #define SUPER Reference
  //---------------------------------------------------------------------------
  template < class T > class TOndemand : public Reference
  {
    public:
      //============== Konstruktoren
      //-----------------------------------------------------------------------
      TOndemand();
      //-----------------------------------------------------------------------
 
    private:
      //============== Konstruktoren
      //-----------------------------------------------------------------------
      TOndemand( const ObjID & rObjID );
      //-----------------------------------------------------------------------
 
    public:
      //============== Konstruktoren
      //-----------------------------------------------------------------------

      TOndemand( const TOndemand & rT );
      template <class T2> TOndemand( const TOndemand<T2> & rT );
      //-----------------------------------------------------------------------
      virtual ~TOndemand();
      //-----------------------------------------------------------------------
 
    public:
      //============== static methods
      //-----------------------------------------------------------------------
      static unsigned long getStaticGloClassID(){ return T::getStaticGloClassID();};
      //-----------------------------------------------------------------------
 
      //============== Methoden
      //-----------------------------------------------------------------------

      int set( const T * rObj );
      int set( const T & rObj );
      int set( const std::shared_ptr<T> & rObj );
      virtual int set( const ObjID & rObj ) override;
      virtual int set( const BasePersistent * rObj ) override;
      virtual int set( const BasePersistent & rObj ) override;
      //-----------------------------------------------------------------------
      int get( T *& prObj );
      //-----------------------------------------------------------------------
      int get( std::shared_ptr<T> & rRetVal );
      //-----------------------------------------------------------------------
 
    public:
      //============== Operatoren
      //-----------------------------------------------------------------------

      TOndemand< T > & operator= ( const TOndemand & rT );
      template <class T2> TOndemand<T> & operator= ( const TOndemand<T2> & rT );
      /*
      Notlösung ohne Fehlermeldung
      TOndemand< T > & operator= ( const Reference & rT )
      {
        if ( this != & rT )
        {
          SUPER::operator=( rT );
        }
        return *this;
      };
      */
      /*
      Geht nur mit Visual Studio 2022
      template <class T2, std::enable_if_t<std::_SP_pointer_compatible<T2, T>::value, int> = 0>
      TOndemand& operator=(const TOndemand<T2>& rT)
      {
        SUPER::set( rT.getObjID() );
        return *this;
      };
      */
      /*
      Von C++ Version 98 nicht unterstützt
      template <class T2, typename = std::enable_if_t<std::is_base_of_v<T, T2>>>
      TOndemand& operator=(const TOndemand<T2>& rT)
      {
        SUPER::set( rT.getObjID() );
        return *this;
      }
      */
      //-----------------------------------------------------------------------

      bool operator== ( const TOndemand & rT ) const;
      bool operator!= ( const TOndemand & rT ) const;
      template <class T2> bool operator== ( const TOndemand<T2>& rT) const;
      template <class T2> bool operator!= ( const TOndemand<T2>& rT) const;
      /*
      Notlösung ohne Fehlermeldung
      bool operator== ( const Reference & rT ) const
      {
        return SUPER::operator==( rT );
      };
      bool operator!= ( const Reference & rT ) const
      {
        return SUPER::operator!=( rT );
      };
      */
      /*
      Geht nur mit Visual Studio 2022
      template <class T2, std::enable_if_t<std::_SP_pointer_compatible<T2, T>::value, int> = 0>
      bool operator==(const TOndemand<T2>& rT)
      {
        return SUPER::operator==( rT );
      }
      template <class T2, std::enable_if_t<std::_SP_pointer_compatible<T2, T>::value, int> = 0>
      bool operator!=(const TOndemand<T2>& rT)
      {
        if ( *this == rT )
        {
          return false;
        }
        return true;
      }
      */
       /*
      Von C++ Version 98 nicht unterstützt
      template <class T2, typename = std::enable_if_t<std::is_base_of_v<T, T2>>>
      bool operator==(const TOndemand<T2>& rT)
      {
        return SUPER::operator==( rT );
      }
      template <class T2, typename = std::enable_if_t<std::is_base_of_v<T, T2>>>
      bool operator!=(const TOndemand<T2>& rT)
      {
        return SUPER::operator!=( rT );
      }
      */
      //-----------------------------------------------------------------------
  };
  template < class T > class TOndemand : public Reference {…};
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand()
  : SUPER()
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  TOndemand< T >::TOndemand() {…}
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand( const ObjID & /*rObjID*/ )
  //: SUPER( rObjID )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
    throw eut::ErrorNException( "TOndemand ctor(const ObjID &, Base &)", ERR_NOT_IMPLEMENTED_YET, __FILE__, __LINE__ );
  }
  TOndemand< T >::TOndemand( const ObjID & /*rObjID*/ ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand( const TOndemand & rT )
  : SUPER( rT )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  TOndemand< T >::TOndemand( const TOndemand & rT ) {…}
  //---------------------------------------------------------------------------
  #if defined(__GNUC__)
    // Warnung: unused variable 't_iDEBUG_XXX' [-Wunused-local-typedefs]
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
  #endif
  //---------------------------------------------------------------------------
  template < class T >
  template <class T2>
  TOndemand< T >::TOndemand( const TOndemand<T2> & rT )
  : SUPER( rT )
  {
    /*
    An error is generated here if the type to be compared is incompatible.
    Check if the compiler output provides more information, such as the incorrect
    call to the comparison operator.
    */
    typedef char TypeCheck[IsBaseClassOf<T, T2>::value ? 1 : -1]; // <- Error if not derived
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  TOndemand< T >::TOndemand( const TOndemand<T2> & rT ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::~TOndemand()
  {
  }
  TOndemand< T >::~TOndemand() {…}
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::set( const T * pObj )
  {
    if (  ! pObj
          ||
          ( pObj
            &&
            ( T::getStaticGloClassID() == pObj->getGloClassID() 
              || 
              T::isStaticSubClassID( pObj->getGloClassID() )
            )
          )
       )
    {
      return SUPER::set( pObj );
    }
    return ERR_WRONG_TYPE;
  }
  int TOndemand< T >::set( const T * pObj ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::set( const T & rObj )
  {
    if (  T::getStaticGloClassID() == rObj.getGloClassID()
          ||
          T::isStaticSubClassID( rObj.getGloClassID() )
       )
    {
      return SUPER::set( rObj );
    }
    return ERR_WRONG_TYPE;
  }
  int TOndemand< T >::set( const T & rObj ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::set( const std::shared_ptr<T> & spObj )
  {
    return this->set( spObj.get() );
  }
  int TOndemand< T >::set( const std::shared_ptr<T> & spObj ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::set( const ObjID & rObjID )
  {
    if (  rObjID.isNULL()
          ||
          ( ! rObjID.isNULL()
            &&
            ( T::getStaticGloClassID() == rObjID.getClassID() 
              || 
              T::isStaticSubClassID( rObjID.getClassID() )
            )
          )
       )
    {
      return SUPER::set( rObjID );
    }
    return ERR_WRONG_TYPE;
  }
  int TOndemand< T >::set( const ObjID & rObjID ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::set( const BasePersistent * pObj )
  {
    if (  pObj->getObjID().isNULL()
          ||
          ( ! pObj->getObjID().isNULL()
            &&
            ( T::getStaticGloClassID() == pObj->getObjID().getClassID() 
              || 
              T::isStaticSubClassID( pObj->getObjID().getClassID() )
            )
          )
       )
    {
      return SUPER::set( pObj->getObjID() );
    }
    return ERR_WRONG_TYPE;
  }
  int TOndemand< T >::set( const BasePersistent * pObj ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::set( const BasePersistent & rObj )
  {
    return this->set( & rObj );
  }
  int TOndemand< T >::set( const BasePersistent & rObj ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::get( T *& prObj )
  {
    int               t_iErr = 0;
    BasePersistent  * t_pGetObj = nullptr;
  
    t_iErr = SUPER::getBasePersistent( t_pGetObj );
    if ( ! t_iErr )
    {
      prObj = dynamic_cast<T*>( t_pGetObj );
      if ( ! prObj )
      {
        t_pGetObj->forget();
        t_iErr = ERR_WRONG_TYPE;
      }
    }
    else
    {
      prObj = nullptr;
    }
    return t_iErr;
  }
  int TOndemand< T >::get( T *& prObj ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::get( std::shared_ptr<T> & rRetVal )
  {
    T    * t_pPersObject = nullptr;
    int    t_iErr = this->get( t_pPersObject );
  
    if ( t_pPersObject )
    {
      rRetVal.reset( t_pPersObject, Forgetter<T>() );
    }
    else
    {
      rRetVal.reset();
    }
    return t_iErr;
  }
  int TOndemand< T >::get( std::shared_ptr<T> & rRetVal ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T > & TOndemand< T >::operator= ( const TOndemand & rT )
  {
    if ( this != & rT )
    {
      SUPER::operator=( rT );
    }
    return *this;
  }
  TOndemand< T > & TOndemand< T >::operator= ( const TOndemand & rT ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  template < class T2 >
  TOndemand<T> & TOndemand< T >::operator= ( const TOndemand<T2> & rT )
  {
    /*
    An error is generated here if the type being assigned is incompatible.
    Check if the compiler output provides more information, such as the incorrect
    call to the assignment operator.
    */
    typedef char TypeCheck[IsBaseClassOf<T, T2>::value ? 1 : -1]; // <- Error if not derived
    if ( (void*) this != & rT )
    {
      SUPER::operator=( rT );
    }
    return *this;
  }
  TOndemand<T> & TOndemand< T >::operator= ( const TOndemand<T2> & rT ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  bool TOndemand< T >::operator== ( const TOndemand & rT ) const
  {
    return SUPER::operator==( rT );
  }
  bool TOndemand< T >::operator== ( const TOndemand & rT ) const {…}
  //---------------------------------------------------------------------------
  template < class T >
  bool TOndemand< T >::operator!= ( const TOndemand & rT ) const
  {
    return SUPER::operator!=( rT );
  }
  bool TOndemand< T >::operator!= ( const TOndemand & rT ) const {…}
  //---------------------------------------------------------------------------
  template < class T >
  template <class T2>
  bool TOndemand< T >::operator== ( const TOndemand<T2>& rT) const
  {
    /*
    An error is generated here if the type to be compared is incompatible.
    Check if the compiler output provides more information, such as the incorrect
    call to the comparison operator.
    */
    typedef char TypeCheck[IsBaseClassOf<T, T2>::value ? 1 : -1]; // <- Error if not derived
    return SUPER::operator==( rT );
  }
  bool TOndemand< T >::operator== ( const TOndemand<T2>& rT) const {…}
  //---------------------------------------------------------------------------
  template < class T >
  template <class T2>
  bool TOndemand< T >::operator!= ( const TOndemand<T2>& rT) const
  {
    /*
    An error is generated here if the type to be compared is incompatible.
    Check if the compiler output provides more information, such as the incorrect
    call to the comparison operator.
    */
    typedef char TypeCheck[IsBaseClassOf<T, T2>::value ? 1 : -1]; // <- Error if not derived
    return SUPER::operator!=( rT );
  }
  bool TOndemand< T >::operator!= ( const TOndemand<T2>& rT) const {…}
  //---------------------------------------------------------------------------
  #if defined(__GNUC__) && ! defined(__clang__)
    // Warnung: variable 't_bWorked' set but not used [-Wunused-local-typedefs]
    #pragma GCC diagnostic pop
  #endif
  //---------------------------------------------------------------------------
  #undef SUPER
  //---------------------------------------------------------------------------
} // namespace glo
#endif