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"
//-----------------------------------------------------------------------------
namespace glo
{
  //---------------------------------------------------------------------------
  template < class T > class TOndemand : public Reference
  {
    public:
      //============== Konstruktoren
      //-----------------------------------------------------------------------
      TOndemand();
      //-----------------------------------------------------------------------
      TOndemand( const ObjID & rObjID );
      //-----------------------------------------------------------------------
      TOndemand( Base & rBase );
      //-----------------------------------------------------------------------
      TOndemand( unsigned long ulDatabaseID );
      //-----------------------------------------------------------------------
      TOndemand( const ObjID & rObjID, Base & rBase );
      //-----------------------------------------------------------------------
      TOndemand( const ObjID & rObjID, unsigned long ulDatabaseID );
      //-----------------------------------------------------------------------
      TOndemand( const TOndemand & 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 );
      //-----------------------------------------------------------------------
      int get( T *& prObj );
      //-----------------------------------------------------------------------
      int get( std::shared_ptr<T> & rRetVal );
      //-----------------------------------------------------------------------
      virtual int setReference( const ObjID & rObjID ) override;
      //-----------------------------------------------------------------------
 
    public:
      //============== Operatoren
      //-----------------------------------------------------------------------

      TOndemand< T > & operator= ( const TOndemand & rT );
      //TOndemand< T > & operator= ( const Reference & rT );
      //-----------------------------------------------------------------------

      bool operator== ( const TOndemand & rT ) const;
      bool operator!= ( const TOndemand & rT ) const;
      //-----------------------------------------------------------------------
  };
  template < class T > class TOndemand : public Reference {…};
  //---------------------------------------------------------------------------
  #define SUPER 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
  }
  TOndemand< T >::TOndemand( const ObjID & rObjID ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand( Base & rBase )
  : SUPER( rBase )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  TOndemand< T >::TOndemand( Base & rBase ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand( unsigned long ulDatabaseID )
  : SUPER( ulDatabaseID )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  TOndemand< T >::TOndemand( unsigned long ulDatabaseID ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand( const ObjID & rObjID, Base & rBase )
  : SUPER( rObjID, rBase )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  TOndemand< T >::TOndemand( const ObjID & rObjID, Base & rBase ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand( const ObjID & rObjID, unsigned long ulDatabaseID )
  : SUPER( rObjID, ulDatabaseID )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  TOndemand< T >::TOndemand( const ObjID & rObjID, unsigned long ulDatabaseID ) {…}
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand( const TOndemand & rT )
  : SUPER( rT )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  TOndemand< T >::TOndemand( const TOndemand & 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::setReference( 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::setReference( 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 >::get( T *& prObj )
  {
    int               t_iErr = 0;
    BasePersistent  * t_pGetObj = nullptr;
  
    t_iErr = SUPER::getReference( 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 >
  int TOndemand< T >::setReference( const ObjID & rObjID )
  {
    if (  rObjID.isNULL()
          ||
          ( ! rObjID.isNULL()
            &&
            ( T::getStaticGloClassID() == rObjID.getClassID() 
              || 
              T::isStaticSubClassID( rObjID.getClassID() )
            )
          )
       )
    {
      return SUPER::setReference( rObjID );
    }
    return ERR_WRONG_TYPE;
  }
  int TOndemand< T >::setReference( const ObjID & rObjID ) {…}
  //---------------------------------------------------------------------------
  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 >
  //TOndemand< T > & TOndemand< T >::operator= ( const Reference & rT )
  //{
  //  if ( this != & rT )
  //  {
  //    SUPER::operator=( rT );
  //  }
  //  return *this;
  //}
  //---------------------------------------------------------------------------
  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
  {
    if ( *this == rT )
    {
      return false;
    }
    return true;
  }
  bool TOndemand< T >::operator!= ( const TOndemand & rT ) const {…}
  //---------------------------------------------------------------------------
  #undef SUPER
  //---------------------------------------------------------------------------
} // namespace glo
#endif