GloTAllSet.h

gehe zur Dokumentation dieser Datei

#ifndef INC_GLOTALLSET_H
#define INC_GLOTALLSET_H
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#include <list>
#include "GloTypes.h"
#include "GloBaseAllSet.h"
#include "GloBasePersistent.h"
#include "GloBase.h"
#include "GloObjectMaker.h"
//-----------------------------------------------------------------------------
namespace glo
{
  //---------------------------------------------------------------------------
  template < class T > class TAllSet : public BaseAllSet
  {
    public:
      //============== Konstruktoren
      //-----------------------------------------------------------------------
      TAllSet();
      //-----------------------------------------------------------------------
      TAllSet( Base & rBase, bool bWithSubClasses = true );
      //-----------------------------------------------------------------------
      TAllSet( Base & rBase, const std::string & rsFullIndexName );
      //-----------------------------------------------------------------------
      virtual ~TAllSet();
      //-----------------------------------------------------------------------
 
    private:
      //============== Konstruktoren
      //-----------------------------------------------------------------------
      TAllSet( const TAllSet & );
      //-----------------------------------------------------------------------
 
    public:
      //============== Methoden
      //-----------------------------------------------------------------------
      int get( T *& prRetVal, EnSeekMode eMode );
      //-----------------------------------------------------------------------
      int get( std::shared_ptr<T> & rRetVal, EnSeekMode eMode );
      //-----------------------------------------------------------------------
      int get( glo::ObjID & rObjID, T *& prRetVal, EnSeekMode eMode );
      //-----------------------------------------------------------------------
      int get( glo::ObjID & rObjID, std::shared_ptr<T> & rRetVal, EnSeekMode eMode );
      //-----------------------------------------------------------------------
 
      virtual int getPersistent( BasePersistent *& prRetVal, const glo::ObjID & rObjID );
      int get( T *& prRetVal, const glo::ObjID & rObjID );
      //-----------------------------------------------------------------------
      int get( std::shared_ptr<T> & rRetVal, const glo::ObjID & rObjID );
      //-----------------------------------------------------------------------
      virtual int getPersistent(  std::shared_ptr<BasePersistent> & rRetVal,
                                  const glo::ObjID & rObjID );
      //-----------------------------------------------------------------------
      int getOndemand( glo::TOndemand<T> *& prRetVal, EnSeekMode eMode );
      //-----------------------------------------------------------------------
      int getOndemand( std::shared_ptr< glo::TOndemand<T> > & rRetVal, EnSeekMode eMode );
      //-----------------------------------------------------------------------
      int getOndemand( glo::TOndemand<T> & rRetVal, EnSeekMode eMode );
      //-----------------------------------------------------------------------
      int getIndexedOndemands(  std::vector< glo::TOndemand<T> > & rOndemandVector,
                                const std::string & rsIndexSearchValue,
                                EnQueryType eQuerryType );
      //-----------------------------------------------------------------------
      int getIndexedOndemands(  std::vector< glo::TOndemand<T> > & rOndemandVector,
                                const std::string & rsFullIndexName,
                                const std::string & rsIndexSearchValue,
                                EnQueryType eQuerryType );
      //-----------------------------------------------------------------------
      int getIndexedOndemands(  std::vector< glo::TOndemand<T> > & rOndemandVector,
                                const std::string & rsIndexName,
                                unsigned long ulIndexClassID,
                                const std::string & rsIndexSearchValue,
                                EnQueryType eQuerryType );
      //-----------------------------------------------------------------------
      int getIndexedOndemands(  std::vector< glo::TOndemand<T> > & rOndemandVector,
                                const std::string & rsIndexSearchValue,
                                EnComparisionOp eComparisionOp );
      //-----------------------------------------------------------------------
      int getIndexedOndemands(  std::vector< glo::TOndemand<T> > & rOndemandVector,
                                const std::string & rsFullIndexName,
                                const std::string & rsIndexSearchValue,
                                EnComparisionOp eComparisionOp );
      //-----------------------------------------------------------------------
      int getIndexedOndemands(  std::vector< glo::TOndemand<T> > & rOndemandVector,
                                const std::string & rsIndexName,
                                unsigned long ulIndexClassID,
                                const std::string & rsIndexSearchValue,
                                EnComparisionOp eComparisionOp );
      //-----------------------------------------------------------------------
      int getIndexedOndemands(  std::vector< glo::TOndemand<T> > & rOndemandVector,
                                const std::string & rsRangeStartIndex,
                                const std::string & rsRangeEndIndex );
      //-----------------------------------------------------------------------
      int getIndexedOndemands(  std::vector< glo::TOndemand<T> > & rOndemandVector,
                                const std::string & rsFullIndexName,
                                const std::string & rsRangeStartIndexSearchValue,
                                const std::string & rsRangeEndIndexSearchValue );
      //-----------------------------------------------------------------------
      int getIndexedOndemands(  std::vector< glo::TOndemand<T> > & rOndemandVector,
                                const std::string & rsIndexName,
                                unsigned long ulIndexClassID,
                                const std::string & rsRangeStartIndexSearchValue,
                                const std::string & rsRangeEndIndexSearchValue );
      //-----------------------------------------------------------------------
      virtual int setWatch( TdWatchNotifyMode ulWatchMode, CallBack * pCallBack = 0 );
      //-----------------------------------------------------------------------
      virtual int unsetWatch( TdWatchNotifyMode ulWatchMode, CallBack * pCallBack = 0 );
      //-----------------------------------------------------------------------
 
    private:
      //============== Methoden
      //-----------------------------------------------------------------------
      void transferObjIListIntoOndemandVector(  const std::vector< glo::ObjID > & rSourceContainer,
                                                std::vector< glo::TOndemand<T> > & rTargetVevtor );
      //-----------------------------------------------------------------------
 
      //============== Operatoren
      //-----------------------------------------------------------------------
      TAllSet< T > & operator= ( const TAllSet & );
      //-----------------------------------------------------------------------
  };
  //---------------------------------------------------------------------------
  #define SUPER BaseAllSet
  //---------------------------------------------------------------------------
  template < class T >
  TAllSet< T >::TAllSet()
  : SUPER()
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TAllSet";
    #endif
    std::shared_ptr<T>  t_TempT( new T, Forgetter<T>() );
    SUPER::setClassIDFromTemplate( t_TempT->getGloClassID() );
  }
  //---------------------------------------------------------------------------
  template < class T >
  TAllSet< T >::TAllSet( Base & rBase, bool bWithSubClasses )
  : SUPER( rBase, 0, bWithSubClasses )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TAllSet";
    #endif
    std::shared_ptr<T>  t_TempT( new T, Forgetter<T>() );
    SUPER::setClassIDFromTemplate( t_TempT->getGloClassID() );
  }
  //---------------------------------------------------------------------------
  template < class T >
  TAllSet< T >::TAllSet( Base & rBase, const std::string  & rsFullIndexName )
  : SUPER( rBase, 0 )
  {
    #ifdef _DEBUG
      m_strDebugInfo = "TAllSet";
    #endif
    std::shared_ptr<T>  t_TempT( new T, Forgetter<T>() );
    SUPER::setClassIDFromTemplate( t_TempT->getGloClassID() );
    int   t_iErr = SUPER::setFullIndexName( rsFullIndexName );
    if ( t_iErr )
    {
      throw eut::ErrorNException( "TAllSet::setBase(Base * pBase, unsigned long ulClassID, const std::string  & rsFullIndexName)", t_iErr, __FILE__, __LINE__ );
    }
  }
  //---------------------------------------------------------------------------
  template < class T >
  TAllSet< T >::~TAllSet()
  {
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::get( T *& prRetVal, EnSeekMode eMode )
  {
    ObjID t_TempObjID;
    return this->get( t_TempObjID, prRetVal, eMode );
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::get( std::shared_ptr<T> & rRetVal, EnSeekMode eMode )
  {
    ObjID t_TempObjID;
    return this->get( t_TempObjID, rRetVal, eMode );
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::get(  ObjID & rObjID, T *& prRetVal, EnSeekMode eMode )
  {
    int t_iErr = 0;
  
    prRetVal = nullptr;
    t_iErr = this->open();
    if ( ! t_iErr )
    {
      BasePersistent * t_pGetObj = nullptr;
 
      t_iErr = this->getBase()->getObjectFromAllSet( rObjID, t_pGetObj, *this, eMode );
      if ( ! t_iErr )
      {
        do
        {
          prRetVal = dynamic_cast<T*>( t_pGetObj );
          if ( ! prRetVal )
          {
            t_pGetObj->forget();
 
            if ( eMode == glo::START || eMode == glo::NEXT )
            {
              t_iErr = this->getBase()->getObjectFromAllSet( rObjID, t_pGetObj, *this, glo::NEXT );
            }
            else if ( eMode == glo::END || eMode == glo::PREVIOUS )
            {
              t_iErr = this->getBase()->getObjectFromAllSet( rObjID, t_pGetObj, *this, glo::PREVIOUS );
            }
          }
          else
          {
           break;
          }
        } while ( ! t_iErr );
      }
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::get( ObjID & rObjID, std::shared_ptr<T> & rRetVal, EnSeekMode eMode )
  {
    T    * t_pPersistent = nullptr;
    int    t_iErr = this->get( rObjID, t_pPersistent, eMode );
  
    if ( t_pPersistent )
    {
      rRetVal = std::shared_ptr<T>( t_pPersistent, Forgetter<T>() );
    }
    else
    {
      rRetVal.reset();
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getPersistent( BasePersistent *& prRetVal, const ObjID & rObjID )
  {
    int   t_iErr = 0;
 
    prRetVal = nullptr;
    if ( ! this->getBase() ) return ERR_NO_BASE;
    //if ( this->getBase()->objIDInAllSet( rObjID, *this ) )
    //{
      t_iErr = this->getBase()->getAnObject( prRetVal, rObjID );
    //}
    //else
    //{
    //  return ERR_OBJID_NOT_IN_ALLSET;
    //}
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::get( T *& prRetVal, const ObjID & rObjID )
  {
    int   t_iErr = 0;
 
    prRetVal = nullptr;
    t_iErr = this->open();
    if ( ! t_iErr )
    {
      BasePersistent * t_pReceivedObject = nullptr;
      //if ( this->getBase()->objIDInAllSet( rObjID, *this ) )
      //{
        t_iErr = this->getBase()->getAnObject( t_pReceivedObject, rObjID );
        if ( ! t_iErr )
        {
          prRetVal = dynamic_cast<T*>( t_pReceivedObject );
          if ( ! prRetVal )
          {
            t_pReceivedObject->forget();
            t_iErr = ERR_WRONG_TYPE;
          }
        }
      //}
      //else
      //{
      //  return ERR_OBJID_NOT_IN_ALLSET;
      //}
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::get(  std::shared_ptr<T> & rRetVal, const ObjID & rObjID )
  {
    T    * t_pPersistent = nullptr;
    int    t_iErr = this->get( t_pPersistent, rObjID );
 
    if ( t_pPersistent )
    {
      rRetVal = std::shared_ptr<T>( t_pPersistent, Forgetter<T>() );
    }
    else
    {
      rRetVal.reset();
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getPersistent(  std::shared_ptr<BasePersistent> & rRetVal,
                                    const ObjID & rObjID )
  {
    return SUPER::getPersistent( rRetVal, rObjID );
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getOndemand(  TOndemand<T> *& prRetVal, EnSeekMode eMode )
  {
    int   t_iErr = 0;
  
    t_iErr = this->open();
    if ( ! t_iErr )
    {
      ObjID    t_ObjID;
 
      t_iErr = this->getBase()->getObjIdFromAllSet( t_ObjID, *this, eMode );
      if ( ! t_iErr )
      {
        // Erfragen, ob ObjID-Klasse hier verarbeitbar
        bool    t_bIsKnownClassID = false;
 
        t_iErr = this->getBase()->isKnownClassID( t_bIsKnownClassID, t_ObjID.getClassID() );
        if ( ! t_iErr )
        {
          if ( ! t_bIsKnownClassID )
          {
            // Unbekannte Klasse! Auch OK, dann nächstes oder vorheriges Objekt
            if ( eMode == START || eMode == NEXT )
            {
              t_iErr = this->getOndemand( prRetVal, NEXT );
            }
            else if ( eMode == END || eMode == PREVIOUS )
            {
              t_iErr = this->getOndemand( prRetVal, PREVIOUS );
            }
          }
          else
          {
            prRetVal = new TOndemand<T>( t_ObjID, * this->getBase() );
          }
        }
      }
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getOndemand( std::shared_ptr< TOndemand<T> > & rRetVal, EnSeekMode eMode )
  {
    TOndemand<T>  * t_pTempGloTOndemand = nullptr;
    int             t_iErr = this->getOndemand( t_pTempGloTOndemand, eMode );
 
    if ( t_pTempGloTOndemand )
    {
      rRetVal = std::shared_ptr<T>( t_pTempGloTOndemand );
    }
    else
    {
      rRetVal.reset();
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getOndemand(  TOndemand<T> & rRetVal, EnSeekMode eMode )
  {
    TOndemand<T>  * t_pTempGloTOndemand = nullptr;
    int             t_iErr = this->getOndemand( t_pTempGloTOndemand, eMode );
 
    if ( t_pTempGloTOndemand )
    {
      rRetVal = * t_pTempGloTOndemand;
      delete t_pTempGloTOndemand;
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getIndexedOndemands(  std::vector< TOndemand<T> > & rOndemandVector,
                                          const std::string & rsIndexSearchValue,
                                          EnQueryType eQuerryType )
  {
    int                     t_iErr = 0;
    std::vector< ObjID >    t_ObjIDContainer;
 
    t_iErr = this->getIndexedObjIds(  t_ObjIDContainer,
                                      rsIndexSearchValue,
                                      eQuerryType );
    if ( ! t_iErr )
    {
      this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getIndexedOndemands(  std::vector< TOndemand<T> > & rOndemandVector,
                                          const std::string & rsFullIndexName,
                                          const std::string & rsIndexSearchValue,
                                          EnQueryType eQuerryType )
  {
    int                     t_iErr = 0;
    std::vector< ObjID >    t_ObjIDContainer;
 
    t_iErr = this->getIndexedObjIds(  t_ObjIDContainer,
                                      rsFullIndexName,
                                      rsIndexSearchValue,
                                      eQuerryType );
    if ( ! t_iErr )
    {
      this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getIndexedOndemands(  std::vector< TOndemand<T> > & rOndemandVector,
                                          const std::string & rsIndexName,
                                          unsigned long ulIndexClassID,
                                          const std::string & rsIndexSearchValue,
                                          EnQueryType eQuerryType )
  {
    int                     t_iErr = 0;
    std::vector< ObjID >    t_ObjIDContainer;
 
    t_iErr = this->getIndexedObjIds(  t_ObjIDContainer,
                                      rsIndexName,
                                      ulIndexClassID,
                                      rsIndexSearchValue,
                                      eQuerryType );
    if ( ! t_iErr )
    {
      this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getIndexedOndemands(  std::vector< TOndemand<T> > & rOndemandVector,
                                          const std::string & rsIndexSearchValue,
                                          EnComparisionOp eComparisionOp )
  {
    int                     t_iErr = 0;
    std::vector< ObjID >    t_ObjIDContainer;
 
    t_iErr = this->getIndexedObjIds(  t_ObjIDContainer,
                                      rsIndexSearchValue,
                                      eComparisionOp );
 
    if ( ! t_iErr )
    {
      this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getIndexedOndemands(  std::vector< TOndemand<T> > & rOndemandVector,
                                          const std::string & rsFullIndexName,
                                          const std::string & rsIndexSearchValue,
                                          EnComparisionOp eComparisionOp )
  {
    int                     t_iErr = 0;
    std::vector< ObjID >    t_ObjIDContainer;
 
    t_iErr = this->getIndexedObjIds(  t_ObjIDContainer,
                                      rsFullIndexName,
                                      rsIndexSearchValue,
                                      eComparisionOp );
 
    if ( ! t_iErr )
    {
      this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getIndexedOndemands(  std::vector< TOndemand<T> > & rOndemandVector,
                                          const std::string & rsIndexName,
                                          unsigned long ulIndexClassID,
                                          const std::string & rsIndexSearchValue,
                                          EnComparisionOp eComparisionOp )
  {
    int                     t_iErr = 0;
    std::vector< ObjID >    t_ObjIDContainer;
 
    t_iErr = this->getIndexedObjIds(  t_ObjIDContainer,
                                      rsIndexName,
                                      ulIndexClassID,
                                      rsIndexSearchValue,
                                      eComparisionOp );
 
    if ( ! t_iErr )
    {
      this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getIndexedOndemands(  std::vector< TOndemand<T> > & rOndemandVector,
                                          const std::string & rsRangeStartIndex,
                                          const std::string & rsRangeEndIndex )
  {
    int                     t_iErr = 0;
    std::vector< ObjID >    t_ObjIDContainer;
 
    t_iErr = this->getIndexedObjIds(  t_ObjIDContainer,
                                      rsRangeStartIndex,
                                      rsRangeEndIndex );
 
    if ( ! t_iErr )
    {
      this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getIndexedOndemands(  std::vector< TOndemand<T> > & rOndemandVector,
                                          const std::string & rsFullIndexName,
                                          const std::string & rsRangeStartIndexSearchValue,
                                          const std::string & rsRangeEndIndexSearchValue )
  {
    int                     t_iErr = 0;
    std::vector< ObjID >    t_ObjIDContainer;
 
    t_iErr = this->getIndexedObjIds(  t_ObjIDContainer,
                                      rsFullIndexName,
                                      rsRangeStartIndexSearchValue,
                                      rsRangeEndIndexSearchValue );
 
    if ( ! t_iErr )
    {
      this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::getIndexedOndemands(  std::vector< TOndemand<T> > & rOndemandVector,
                                          const std::string & rsIndexName,
                                          unsigned long ulIndexClassID,
                                          const std::string & rsRangeStartIndexSearchValue,
                                          const std::string & rsRangeEndIndexSearchValue )
  {
    int                     t_iErr = 0;
    std::vector< ObjID >    t_ObjIDContainer;
 
    t_iErr = this->getIndexedObjIds(  t_ObjIDContainer,
                                      rsIndexName,
                                      ulIndexClassID,
                                      rsRangeStartIndexSearchValue,
                                      rsRangeEndIndexSearchValue );
 
    if ( ! t_iErr )
    {
      this->transferObjIListIntoOndemandVector( t_ObjIDContainer, rOndemandVector );
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::setWatch( TdWatchNotifyMode ulWatchMode, CallBack * pCallBack )
  {
    int   t_iErr = this->open();
 
    if ( ! t_iErr )
    {
      if ( ! this->getBase()->getObjectMaker() ) t_iErr = ERR_BASE_NOT_OPEN;
      if ( ! t_iErr )
      {
        if ( ! pCallBack )
        {
          TAllSet< T > * t_pConstCastThis = const_cast<TAllSet< T >*>( this );
 
          pCallBack = t_pConstCastThis;
        }
        t_iErr = this->getBase()->setWatchClass(  this->getBase()->getObjectMaker()->getClassID( this ),
                                                  ulWatchMode,
                                                  pCallBack );
      }
    }
    return t_iErr;
  }
  //---------------------------------------------------------------------------
  template < class T >
  int TAllSet< T >::unsetWatch( TdWatchNotifyMode ulWatchMode, CallBack * pCallBack )
  {
    if ( ! this->getBase() ) return ERR_NO_BASE;
    if ( ! this->getBase()->getObjectMaker() ) return ERR_BASE_NOT_OPEN;
  
    if ( ! pCallBack )
    {
      TAllSet< T > * t_pConstCastThis = const_cast<TAllSet< T >*>( this );
 
      pCallBack = t_pConstCastThis;
    }
    return this->getBase()->unsetWatchClass( this->getBase()->getObjectMaker()->getClassID( this ),
                                             ulWatchMode, pCallBack );
  }
  //---------------------------------------------------------------------------
  template < class T >
  void TAllSet< T >::transferObjIListIntoOndemandVector(  const std::vector< glo::ObjID > & rSourceContainer,
                                                          std::vector< TOndemand<T> > & rTargetVevtor )
  {
    for ( std::vector<ObjID>::const_iterator t_Iterator = rSourceContainer.begin();
          t_Iterator != rSourceContainer.end();
          ++t_Iterator )
    {
      rTargetVevtor.push_back( TOndemand<T>( * t_Iterator, * this->getBase() ) );
    }
  }
  //---------------------------------------------------------------------------
  #undef SUPER
  //---------------------------------------------------------------------------
} // namespace glo
#endif