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( const ObjID & rObjID, Base & rBase );
      //-----------------------------------------------------------------------
      TOndemand( const TOndemand & rT );
      //-----------------------------------------------------------------------
      virtual ~TOndemand();
      //-----------------------------------------------------------------------
 
      //============== Methoden
      //-----------------------------------------------------------------------
      int set( const T * pObj );
      //-----------------------------------------------------------------------
      int set( const T & rObj );
      //-----------------------------------------------------------------------
      int set( const std::shared_ptr<T> & spObj );
      //-----------------------------------------------------------------------
      int get( T *& prObj ) const;
      //-----------------------------------------------------------------------
      int get( std::shared_ptr<T> & rRetVal ) const;
      //-----------------------------------------------------------------------
      virtual void setReference( const ObjID & rObjID );
      //-----------------------------------------------------------------------
 
    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;
      //-----------------------------------------------------------------------
  };
  //---------------------------------------------------------------------------
  #define SUPER Reference
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand()
  : SUPER()
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand( const ObjID & rObjID )
  : SUPER( rObjID )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand( Base & rBase )
  : SUPER( rBase )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand(  const ObjID & rObjID,
                              Base & rBase )
  : SUPER( rObjID, rBase )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::TOndemand( const TOndemand & rT )
  : SUPER( rT )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TOndemand";
    #endif
  }
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T >::~TOndemand()
  {
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::set( const T * pObj )
  {
    return SUPER::setReference( pObj );
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::set( const T & rObj )
  {
    return SUPER::setReference( rObj );
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::set( const std::shared_ptr<T> & spObj )
  {
    return SUPER::setReference( spObj.get() );
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::get( T *& prObj ) const 
  {
    int               t_iErr = 0;
    BasePersistent  * t_pGetObj = 0;
  
    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;
      }
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TOndemand< T >::get( std::shared_ptr<T> & rRetVal ) const 
  {
    T    * t_pPersObject = 0;
    int    t_iErr = this->get( t_pPersObject );
  
    if ( t_pPersObject )
    {
      //rRetVal = std::shared_ptr<T>( t_pPersObject, Forgeter<T>() );
      rRetVal.reset( t_pPersObject, Forgeter<T>() );
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  void TOndemand< T >::setReference( const ObjID & rObjID )
  {
    SUPER::setReference( rObjID );
  }
  //---------------------------------------------------------------------------
  template < class T >
  TOndemand< T > & TOndemand< T >::operator= ( const TOndemand & rT )
  {
    if ( this != & rT )
    {
      SUPER::operator=( rT );
    }
    return *this;
  }
  //---------------------------------------------------------------------------
  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 );
  }
  //---------------------------------------------------------------------------
  template < class T >
  bool TOndemand< T >::operator!= ( const TOndemand & rT ) const
  {
    if ( *this == rT )
    {
      return false;
    }
    return true;
  }
  //---------------------------------------------------------------------------
  #undef SUPER
  //---------------------------------------------------------------------------
} // namespace glo
#endif