db/d1d/_glo_index_pool_8h_source.html

#ifndef INC_GLOINDEXPOOL_H

#define INC_GLOINDEXPOOL_H

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

#include "GloTypes.h"

#include "GloWatchNotifyManager.h"

#include "GloObjID.h"

#include "GloClassInfoAttribute.h"

#include "GloClassInfoIndex.h"

#if defined (__PTHREADS)

  #include <EuPCriticalSection.h>

#else

  #include "EuCriticalSection.h"

#endif

#include <ctime>

#include <list>

#include <map>


#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)

  #include <basetsd.h>

#elif defined(__GNUC__)

  #define INT_PTR intptr_t

#endif

//-----------------------------------------------------------------------------

namespace glo

{

  //---------------------------------------------------------------------------

  /* Forwards */

  class SchemaInterface;

  class ClassInfoIndex;

  class WatchNotifyManager;

  //---------------------------------------------------------------------------

  #ifdef _MSC_VER

    /* 'Bezeichner': Klasse 'Typ' benötigt eine DLL-Schnittstelle, die von... */

    #pragma warning( disable : 4251 )

  #endif

  //---------------------------------------------------------------------------


  class __glo_export_dll IndexPool

  {

    public:

      //-----------------------------------------------------------------------

      // >>>>>>>>>>>>>>>>>>>>>> DeletedObjIdTuple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

      //-----------------------------------------------------------------------


      class DeletedObjIdTuple

      {

        public:

          //============== Attribute

          //---------------------------------------------------------------------

          ObjID m_ObjID;

          //---------------------------------------------------------------------

          int m_iDelCounter;

          //---------------------------------------------------------------------


          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          DeletedObjIdTuple();

          //---------------------------------------------------------------------

          DeletedObjIdTuple( const ObjID & rObjID, int iDelCounter );

          //---------------------------------------------------------------------

          DeletedObjIdTuple( const DeletedObjIdTuple & rT );

          //---------------------------------------------------------------------

          virtual ~DeletedObjIdTuple();

          //---------------------------------------------------------------------


          //============== Methoden

          //---------------------------------------------------------------------

          std::string toString() const;

          //---------------------------------------------------------------------


          //============== Operatoren

          //---------------------------------------------------------------------

          bool operator== ( const DeletedObjIdTuple & rT ) const;

          bool operator!= ( const DeletedObjIdTuple & rT ) const;

          bool operator> ( const DeletedObjIdTuple & rT ) const;

          bool operator>= ( const DeletedObjIdTuple & rT ) const;

          bool operator< ( const DeletedObjIdTuple & rT ) const;

          bool operator<= ( const DeletedObjIdTuple & rT ) const;

          //---------------------------------------------------------------------

          bool operator== ( int iDelCounter ) const;

          bool operator!= ( int iDelCounter ) const;

          bool operator> ( int iDelCounter ) const;

          bool operator>= ( int iDelCounter ) const;

          bool operator< ( int iDelCounter ) const;

          bool operator<= ( int iDelCounter ) const;

          //---------------------------------------------------------------------

          IndexPool::DeletedObjIdTuple & operator= ( const DeletedObjIdTuple & rT );

          //---------------------------------------------------------------------

      };


      //-----------------------------------------------------------------------

      // <<<<<<<<<<<<<<<<<<<<<< DeletedObjIdTuple <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

      //-----------------------------------------------------------------------


      //-----------------------------------------------------------------------

      // >>>>>>>>>>>>>>>>>>>>>>>> ObjIdPosTuple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

      //-----------------------------------------------------------------------


      class ObjIdPosTuple

      {

        public:

          //============== Attribute

          //---------------------------------------------------------------------

          ObjID m_ObjID;

          //---------------------------------------------------------------------

          std::streampos m_FilePosition;

          //---------------------------------------------------------------------


          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          ObjIdPosTuple();

          //---------------------------------------------------------------------

          ObjIdPosTuple( const ObjID & rObjID, std::streampos FilePosition );

          //---------------------------------------------------------------------

          ObjIdPosTuple( const ObjIdPosTuple & rT );

          //---------------------------------------------------------------------

          virtual ~ObjIdPosTuple();

          //---------------------------------------------------------------------


          //============== Methoden

          //---------------------------------------------------------------------

          std::string toString() const;

          //---------------------------------------------------------------------


          //============== Operatoren

          //---------------------------------------------------------------------

          bool operator== ( const ObjIdPosTuple & rT ) const;

          bool operator!= ( const ObjIdPosTuple & rT ) const;

          bool operator> ( const ObjIdPosTuple & rT ) const;

          bool operator>= ( const ObjIdPosTuple & rT ) const;

          bool operator< ( const ObjIdPosTuple & rT ) const;

          bool operator<= ( const ObjIdPosTuple & rT ) const;

          //---------------------------------------------------------------------

          bool operator== ( std::streampos Pos ) const;

          bool operator!= ( std::streampos Pos ) const;

          bool operator> ( std::streampos Pos ) const;

          bool operator>= ( std::streampos Pos ) const;

          bool operator< ( std::streampos Pos ) const;

          bool operator<= ( std::streampos Pos ) const;

          //---------------------------------------------------------------------

          IndexPool::ObjIdPosTuple & operator= ( const ObjIdPosTuple & rT );

          //---------------------------------------------------------------------

      };


      //-----------------------------------------------------------------------

      // <<<<<<<<<<<<<<<<<<<<<<< ObjIdPosTuple <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

      //-----------------------------------------------------------------------


      //-----------------------------------------------------------------------

      // >>>>>>>>>>>>>>>>>>>>>>> ObjStrIdTuple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

      //-----------------------------------------------------------------------


      class ObjStrIdTuple

      {

        private:

          //============== Attribute

          //---------------------------------------------------------------------

          std::string m_sIndex;

          //---------------------------------------------------------------------

          ObjID m_ObjID;

          //---------------------------------------------------------------------

          NUM_PTR m_ipReservingComunicatorTrx;

          //---------------------------------------------------------------------


        public:

          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          ObjStrIdTuple();

          //---------------------------------------------------------------------

          ObjStrIdTuple( const std::string & rsIndex,

                         const ObjID & rObjID,

                         NUM_PTR ipReservingComunicatorTrx = 0 );

          //---------------------------------------------------------------------

          ObjStrIdTuple( const ObjStrIdTuple & rT );

          //---------------------------------------------------------------------

          virtual ~ObjStrIdTuple();

          //---------------------------------------------------------------------


          //============== Methoden

          //---------------------------------------------------------------------

          void setValues( const std::string & rsIndex,

                          const ObjID & rObjID,

                          NUM_PTR ipReservingComunicatorTrx = 0 );

          //---------------------------------------------------------------------

          void setIndex( const std::string & rsIndex );

          //---------------------------------------------------------------------

          void setObjID( const ObjID & rObjID );

          //---------------------------------------------------------------------

          void setReservingComunicatorTrx( NUM_PTR ipReservingComunicatorTrx );

          //---------------------------------------------------------------------

          std::string getIndex() const;

          //---------------------------------------------------------------------

          ObjID getObjID() const;

          //---------------------------------------------------------------------

          NUM_PTR getReservingComunicatorTrx() const;

          //---------------------------------------------------------------------

          std::string toString() const;

          //---------------------------------------------------------------------


          //============== Operatoren

          //---------------------------------------------------------------------

          bool operator== ( const ObjStrIdTuple & rT ) const;

          bool operator!= ( const ObjStrIdTuple & rT ) const;

          bool operator> ( const ObjStrIdTuple & rT ) const;

          bool operator>= ( const ObjStrIdTuple & rT ) const;

          bool operator< ( const ObjStrIdTuple & rT ) const;

          bool operator<= ( const ObjStrIdTuple & rT ) const;

          //---------------------------------------------------------------------

          IndexPool::ObjStrIdTuple & operator= ( const ObjStrIdTuple & rT );

          //---------------------------------------------------------------------

      };


      //-----------------------------------------------------------------------

      // <<<<<<<<<<<<<<<<<<<<<<<< ObjStrIdTuple <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

      //-----------------------------------------------------------------------


      //-----------------------------------------------------------------------

      // >>>>>>>>>>>>>>>>>>>>>>> TableObjIdIndex >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

      //-----------------------------------------------------------------------


      class TableObjIdIndex

      {

        private:

          //============== Attribute

          //---------------------------------------------------------------------

          std::string m_strPathName;

          //---------------------------------------------------------------------

          unsigned long m_ulClassID;

          //---------------------------------------------------------------------

          std::map< ObjID, ObjIdPosTuple *, std::less< ObjID > > m_ObjIDIndexMap;

          //---------------------------------------------------------------------

          std::map< std::streampos, std::streampos , std::less< std::streampos > > m_FreeObjIDPosMap;

          //---------------------------------------------------------------------


          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          TableObjIdIndex();

          //---------------------------------------------------------------------


        public:

          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          TableObjIdIndex( const std::string & rsPathName, unsigned long ulClassID );

          //---------------------------------------------------------------------

          TableObjIdIndex( const TableObjIdIndex & rT );

          //---------------------------------------------------------------------

          virtual ~TableObjIdIndex();

          //---------------------------------------------------------------------


          //============== Methoden

          //---------------------------------------------------------------------

          const std::string & getPathName() const;

          //---------------------------------------------------------------------

          unsigned long getClassID() const;

          //---------------------------------------------------------------------

          const std::map< ObjID, IndexPool::ObjIdPosTuple *, std::less< ObjID > > & getObjIDIndexMapRef() const;

          //---------------------------------------------------------------------

          const std::map< std::streampos, std::streampos , std::less< std::streampos > > & getFreeObjIDPosMapRef() const;

          //---------------------------------------------------------------------

          bool isObjIdFree( const ObjID & rObjID ) const;

          //---------------------------------------------------------------------

          int insertObjIdPosTuple( const ObjIdPosTuple & rIndexTuple );

          //---------------------------------------------------------------------

          int removeObjId( const ObjID & rObjID );

          //---------------------------------------------------------------------

          int getObjIdPosTuple( ObjIdPosTuple *& prRetVal,

                                const ObjID & rObjID ) const;

          //---------------------------------------------------------------------

          int insertFreeObjIDPos( std::streampos Pos );

          //---------------------------------------------------------------------

          int getFreeObjIDPos( std::streampos & rPos ) const;

          //---------------------------------------------------------------------

          int removeFreeObjIDPos( std::streampos Pos );

          //---------------------------------------------------------------------

          void deleteAllIndexValues();

          //---------------------------------------------------------------------

          void removeAllFreeObjIDPos();

          //---------------------------------------------------------------------


        protected:

          //============== Methoden

          //---------------------------------------------------------------------

          void copyMapFrom( const TableObjIdIndex & rT );

          //---------------------------------------------------------------------


        public:

          //============== Operatoren

          //---------------------------------------------------------------------

          IndexPool::TableObjIdIndex & operator= ( const TableObjIdIndex & rT );

          //---------------------------------------------------------------------

      };


      //-----------------------------------------------------------------------

      // <<<<<<<<<<<<<<<<<<<<<<<< TableObjIdIndex <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

      //-----------------------------------------------------------------------


      //-----------------------------------------------------------------------

      // >>>>>>>>>>>>>>>>>>>> TableObjIdIndexIterator >>>>>>>>>>>>>>>>>>>>>>>>>>>

      //-----------------------------------------------------------------------


      class TableObjIdIndexIterator

      {

        private:

          //============== Attribute

          //---------------------------------------------------------------------

          TableObjIdIndex * m_pTableObjIdIndex;

          //---------------------------------------------------------------------

          ObjIdPosTuple * m_pLastTableObjIdIndexItem;

          //---------------------------------------------------------------------

          bool m_bWithSubClasses;

          //---------------------------------------------------------------------


        protected:

          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          TableObjIdIndexIterator();

          //---------------------------------------------------------------------


        public:

          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          TableObjIdIndexIterator( TableObjIdIndex * pTableObjIdIndex );

          //---------------------------------------------------------------------

          TableObjIdIndexIterator (const TableObjIdIndexIterator & rT);

          //---------------------------------------------------------------------

          ~TableObjIdIndexIterator();

          //---------------------------------------------------------------------


          //============== Methoden

          //---------------------------------------------------------------------

          void setWithSubClasses( bool bWithSubClasses );

          //---------------------------------------------------------------------

          bool withSubClasses() const;

          //---------------------------------------------------------------------

          std::size_t getTableObjIdIndexSize() const;

          //---------------------------------------------------------------------

          unsigned long getClassID() const;

          //---------------------------------------------------------------------

          int getObjIdPosTuple( ObjIdPosTuple *& prRetVal, EnSeekMode eMode );

          //---------------------------------------------------------------------

          int setPosition( std::size_t nPosition );

          //---------------------------------------------------------------------

          int setCurrentObject( const ObjID & rObjID );

          //---------------------------------------------------------------------

          bool setNearestObject( const ObjID & rObjID );

          //---------------------------------------------------------------------

          bool inObjIdIndex( const ObjID & rObjID );

          //---------------------------------------------------------------------


        protected:

          //============== Methoden

          //---------------------------------------------------------------------

          bool setNearestObject( std::map< ObjID, ObjIdPosTuple *>::iterator & rIterator,

                                 const ObjID & rObjID );

          //---------------------------------------------------------------------


        public:

          //============== Operatoren

          //---------------------------------------------------------------------

          IndexPool::TableObjIdIndexIterator & operator= ( const TableObjIdIndexIterator & rT );

          //---------------------------------------------------------------------

      };


      //-----------------------------------------------------------------------

      // <<<<<<<<<<<<<<<<<<<< TableObjIdIndexIterator <<<<<<<<<<<<<<<<<<<<<<<<<<<

      //-----------------------------------------------------------------------


      //-----------------------------------------------------------------------

      // >>>>>>>>>>>>>>>>>>>>>>> ObjectStrIndex >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

      //-----------------------------------------------------------------------


      class ObjectStrIndex

      {

        //============== Friends

        //-----------------------------------------------------------------------

        friend class RealIndexPool;

        //-----------------------------------------------------------------------


        private:

          //============== Attribute

          //---------------------------------------------------------------------

          std::string m_strPathName;

          //---------------------------------------------------------------------

          unsigned long m_ulClassID;

          //---------------------------------------------------------------------

          std::string m_sIndexName;

          //---------------------------------------------------------------------

          bool m_bUnique;

          //---------------------------------------------------------------------

          std::map< std::string, ObjStrIdTuple * , std::less< std::string > > m_UniqueIndexMap;

          //---------------------------------------------------------------------

          std::map< std::string, ObjStrIdTuple * >::iterator m_UniqueIndexMapIterator;

          //---------------------------------------------------------------------

          std::multimap< std::string, ObjStrIdTuple * , std::less< std::string > > m_ReservedIndexMultiMap;

          //---------------------------------------------------------------------

          std::multimap< std::string, ObjStrIdTuple * , std::less< std::string > > m_NonUniqueIndexMultiMap;

          //---------------------------------------------------------------------

          std::multimap< std::string, ObjStrIdTuple * >::iterator m_NonUniqueIndexMultiMapIterator;

          //---------------------------------------------------------------------

          std::map< ObjID, ObjStrIdTuple * , std::less< ObjID > > m_ObjIdIndexMap;

          //---------------------------------------------------------------------


        protected:

          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          ObjectStrIndex();

          //---------------------------------------------------------------------


        public:

          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          ObjectStrIndex( const std::string & rsPathName,

                          unsigned long ulClassID,

                          const std::string & rsIndexName,

                          bool bUnique );

          //---------------------------------------------------------------------

          ObjectStrIndex( const ObjectStrIndex & rT );

          //---------------------------------------------------------------------

          virtual ~ObjectStrIndex();

          //---------------------------------------------------------------------


          //============== Methoden

          //---------------------------------------------------------------------

          const std::string & getPathName() const;

          //---------------------------------------------------------------------

          unsigned long getClassID() const;

          //---------------------------------------------------------------------

          const std::string & getIndexName() const;

          //---------------------------------------------------------------------

          bool isUnique() const;

          //---------------------------------------------------------------------

          const std::map< std::string, IndexPool::ObjStrIdTuple * , std::less< std::string > > & getUniqueIndexMapRef() const;

          //---------------------------------------------------------------------

          const std::multimap< std::string, IndexPool::ObjStrIdTuple * , std::less< std::string > > & getNonUniqueIndexMapRef() const;

          //---------------------------------------------------------------------

          const std::map< ObjID, IndexPool::ObjStrIdTuple * , std::less< ObjID > > & getObjIdIndexMapRef() const;

          //---------------------------------------------------------------------

          void reserveObjStrIdTuple( const ObjStrIdTuple & rIndexTuple );

          //---------------------------------------------------------------------

          void releaseObjStrIdTuple( const NUM_PTR ipReservingComunicatorTrx );

          //---------------------------------------------------------------------

          int insertObjStrIdTuple( const ObjStrIdTuple & rIndexTuple );

          //---------------------------------------------------------------------

          int removeObjStrIdTuple( const ObjID & rObjID,

                                   NUM_PTR ipReservingComunicatorTrx = 0 );

          //---------------------------------------------------------------------

          bool isIndexFree( const std::string & rsIndex, const ObjID & rObjID ) const;

          //---------------------------------------------------------------------

          bool isObjIdAlreadyAvailable( const ObjID & rObjID ) const;

          //---------------------------------------------------------------------

          void deleteAllIndexValues();

          //---------------------------------------------------------------------


        protected:

          //============== Methoden

          //---------------------------------------------------------------------

          IndexPool::ObjStrIdTuple * getObjStrIdTuple( const ObjID & rObjID );

          //---------------------------------------------------------------------

          IndexPool::ObjStrIdTuple * getObjStrIdTuple( EnSeekMode eMode );

          //---------------------------------------------------------------------

          int removeObjStrIdTuple( const ObjID & rObjID,

                                   bool bDelete,

                                   NUM_PTR ipReservingComunicatorTrx = 0 );

          //---------------------------------------------------------------------

          void copyMapsFrom( const ObjectStrIndex & rT );

          //---------------------------------------------------------------------


        public:

          //============== Operatoren

          //---------------------------------------------------------------------

          IndexPool::ObjectStrIndex & operator= ( const ObjectStrIndex & rT );

          //---------------------------------------------------------------------

      };


      //-----------------------------------------------------------------------

      // <<<<<<<<<<<<<<<<<<<<<<<< ObjectStrIndex <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

      //-----------------------------------------------------------------------


      //-----------------------------------------------------------------------

      // >>>>>>>>>>>>>>>>>>>>>>>>>>> IndexFilter >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

      //-----------------------------------------------------------------------


      struct IndexFilter

      {

        //-----------------------------------------------------------------------

        std::string m_sIndexFilterValue;

        //-----------------------------------------------------------------------

        virtual ~IndexFilter() {};

       //-----------------------------------------------------------------------

      };


      //-----------------------------------------------------------------------

      // <<<<<<<<<<<<<<<<<<<<<<<<<<< IndexFilter <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

      //-----------------------------------------------------------------------


      //-----------------------------------------------------------------------

      // >>>>>>>>>>>>>>>>>>>>>> IndexComparisionFilter >>>>>>>>>>>>>>>>>>>>>>>>>>

      //-----------------------------------------------------------------------


      struct IndexComparisionFilter : public IndexFilter

      {

        //-----------------------------------------------------------------------

        EnComparisionOp m_eComparisionOperator;

        //-----------------------------------------------------------------------


        IndexComparisionFilter()

        : m_eComparisionOperator( EQUAL )

        {};


        //-----------------------------------------------------------------------

        virtual ~IndexComparisionFilter() {};

        //-----------------------------------------------------------------------

      };


      //-----------------------------------------------------------------------

      // <<<<<<<<<<<<<<<<<<<<<< IndexComparisionFilter <<<<<<<<<<<<<<<<<<<<<<<<<<

      //-----------------------------------------------------------------------


      //-----------------------------------------------------------------------

      // >>>>>>>>>>>>>>>>>>>>>>>>> IndexRangeFilter >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

      //-----------------------------------------------------------------------


      struct IndexRangeFilter : public IndexFilter

      {

        //-----------------------------------------------------------------------

        std::string m_sIndexFilterEndValue;

        //-----------------------------------------------------------------------

        virtual ~IndexRangeFilter() {};

        //-----------------------------------------------------------------------

      };


      //-----------------------------------------------------------------------

      // <<<<<<<<<<<<<<<<<<<<<<<<< IndexRangeFilter <<<<<<<<<<<<<<<<<<<<<<<<<<<<<

      //-----------------------------------------------------------------------


      //-----------------------------------------------------------------------

      // >>>>>>>>>>>>>>>>>>>>> ObjectStrIndexIterator >>>>>>>>>>>>>>>>>>>>>>>>>>>

      //-----------------------------------------------------------------------


      class ObjectStrIndexIterator

      {

        private:

          //============== Attribute

          //---------------------------------------------------------------------

          ObjectStrIndex * m_pObjectStrIndex;

          //---------------------------------------------------------------------

          ObjStrIdTuple * m_pLastObjectStrIndexItem;

          //---------------------------------------------------------------------

          IndexFilter * m_pIndexFilter;

          //---------------------------------------------------------------------


        protected:

          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          ObjectStrIndexIterator();

          //---------------------------------------------------------------------


        public:

          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          ObjectStrIndexIterator( ObjectStrIndex * pObjectStrIndex );

          //---------------------------------------------------------------------

          ObjectStrIndexIterator( const ObjectStrIndexIterator & rT );

          //---------------------------------------------------------------------

          ~ObjectStrIndexIterator();

          //---------------------------------------------------------------------


          //============== Methoden

          //---------------------------------------------------------------------

          std::size_t getObjectStrIndexSize() const;

          //---------------------------------------------------------------------

          unsigned long getClassID() const;

          //---------------------------------------------------------------------

          int getObjStrIdTuple( ObjStrIdTuple & rRetVal, EnSeekMode eMode );

          //---------------------------------------------------------------------

          int getObjStrIdTupleList( std::list<ObjStrIdTuple> & rRetVal,

                                    const std::string & rsIndex,

                                    EnQueryType eQuerryType ) const;

          //---------------------------------------------------------------------

          int getObjStrIdTupleList( std::list<ObjStrIdTuple> & rRetVal,

                                    const std::string & rsIndex,

                                    EnComparisionOp eComparisionOp ) const;

          //---------------------------------------------------------------------

          int getObjStrIdTupleList( std::list<ObjStrIdTuple> & rRetVal,

                                    const std::string & rsRangeStartIndex,

                                    const std::string & rsRangeEndIndex ) const;

          //---------------------------------------------------------------------

          void setFilter( const std::string & rsIndexFilterValue );

          //---------------------------------------------------------------------

          void setFilter( const std::string & rsIndexFilterValue,

                          EnComparisionOp eComparisionOp );

          //---------------------------------------------------------------------

          void setFilter( const std::string & rsRangeStartIndex,

                          const std::string & rsRangeEndIndex );

          //---------------------------------------------------------------------

          void removeFilter();

          //---------------------------------------------------------------------

          void setFilter( IndexFilter * pIndexFilter );

          //---------------------------------------------------------------------

          int setPosition( std::size_t nPosition );

          //---------------------------------------------------------------------

          int setCurrentObject( const ObjID & rObjID );

          //---------------------------------------------------------------------

          bool setNearestObject( const std::string & rsIndex );

          //---------------------------------------------------------------------

          bool inObjectStrIndex( const ObjID & rObjID );

          //---------------------------------------------------------------------

          bool inObjectStrIndex( const std::string & rsIndex );

          //---------------------------------------------------------------------


        protected:

          //============== Methoden

          //---------------------------------------------------------------------

          bool valueMatchesIndexFilter( const std::string & rsSearchIndex,

                                        IndexFilter & rIndexFilter ) const;

          //---------------------------------------------------------------------

          bool valueMatchesComparisonFilter(  const std::string & rsSearchIndex,

                                              IndexComparisionFilter & rIndexComparisionFilter ) const;

          //---------------------------------------------------------------------

          bool valueMatchesRangeFilter( const std::string & rsSearchIndex,

                                        IndexRangeFilter & rIndexRangeFilter ) const;

          //---------------------------------------------------------------------

          int getSearchModeAndSearchIndex(  std::string & rsSearchIndex,

                                            const std::string rsSourceIndex ) const;

          //---------------------------------------------------------------------

          bool setNearestObjectInMap( std::map< std::string, ObjStrIdTuple *>::const_iterator & rIterator,

                                      const std::string & rsIndex );

          //---------------------------------------------------------------------

          bool setNearestObjectInMultiMap(  std::multimap< std::string, ObjStrIdTuple *>::const_iterator & rIterator,

                                            const std::string & rsIndex );

          //---------------------------------------------------------------------


        public:

          //============== Operatoren

          //---------------------------------------------------------------------

          IndexPool::ObjectStrIndexIterator & operator= ( const ObjectStrIndexIterator & rT );

          //---------------------------------------------------------------------

      };


      //-----------------------------------------------------------------------

      // <<<<<<<<<<<<<<<<<<<<< ObjectStrIndexIterator <<<<<<<<<<<<<<<<<<<<<<<<<<<

      //-----------------------------------------------------------------------


      //-----------------------------------------------------------------------

      // >>>>>>>>>>>>>>>>>>>>>>>>> SchemaIndex >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

      //-----------------------------------------------------------------------


      class SchemaIndex

      {

        private:

          //============== Attribute

          //---------------------------------------------------------------------

          std::string m_sSchemaName;

          //---------------------------------------------------------------------

          std::map< unsigned long, TableObjIdIndex * , std::less< unsigned long > > m_TableObjIdIndexMap;

          //---------------------------------------------------------------------

          std::multimap< unsigned long, ObjectStrIndex * , std::less< unsigned long > > m_ObjectStrIndexMap;

          //---------------------------------------------------------------------

          std::map< ObjID, ObjID * , std::less< ObjID > > m_DeletedObjIdMap;

          //---------------------------------------------------------------------

          std::map< ObjID, DeletedObjIdTuple * , std::less< ObjID > > m_TransactionDeletedObjIdMap;

          //---------------------------------------------------------------------


        protected:

          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          SchemaIndex();

          //---------------------------------------------------------------------


        public:

          //============= De- und Konstruktoren

          //---------------------------------------------------------------------

          SchemaIndex( const std::string & rstrName );

          //---------------------------------------------------------------------

          SchemaIndex( const SchemaIndex & rT );

          //---------------------------------------------------------------------

          ~SchemaIndex();

          //---------------------------------------------------------------------


          //============== Methoden

          //---------------------------------------------------------------------

          std::string getSchemaName() const;

          //---------------------------------------------------------------------

          const std::map< unsigned long, IndexPool::TableObjIdIndex * , std::less< unsigned long > > & getTableObjIdIndexMapRef() const;

          //---------------------------------------------------------------------

          int getTableObjIdIndexIterator( TableObjIdIndexIterator *& prTableIterators,

                                          unsigned long ulClassID ) const;

          //---------------------------------------------------------------------

          int makeTableObjIdIndex( const std::string & rsPathName,

                                   unsigned long ulClassID );

          //---------------------------------------------------------------------

          int getTableObjIdIndex( TableObjIdIndex *& prRetVal,

                                  unsigned long ulClassID ) const;

          //---------------------------------------------------------------------

          int removeTableObjIdIndex( unsigned long ulClassID );

          //---------------------------------------------------------------------

          int isObjIdFree( unsigned long ulClassID,

                           const ObjID & rObjID ) const;

          //---------------------------------------------------------------------

          bool isObjIdDeleted (const ObjID & rObjID) const;

          //---------------------------------------------------------------------

          int insertObjIdPosTuple( unsigned long ulClassID,

                                   const ObjIdPosTuple & rIndexTuple );

          //---------------------------------------------------------------------

          int insertDeletedObjID( const ObjID & rDeletedObjId );

          //---------------------------------------------------------------------

          int insertTransactionDeletedObjID( const ObjID & rDeletedObjId );

          //---------------------------------------------------------------------

          int removeTransactionDeletedObjID( const ObjID & rDeletedObjId );

          //---------------------------------------------------------------------

          int removeObjId( unsigned long ulClassID, const ObjID & rObjID );

          //---------------------------------------------------------------------

          int getObjIdPosTuple( ObjIdPosTuple *& prRetVal,

                                unsigned long ulClassID,

                                const ObjID & rObjID ) const;

          //---------------------------------------------------------------------

          int insertFreeObjIDPos( unsigned long ulClassID, std::streampos Pos );

          //---------------------------------------------------------------------

          int getFreeObjIDPos( std::streampos & rPos, unsigned long ulClassID ) const;

          //---------------------------------------------------------------------

          int removeFreeObjIDPos( unsigned long ulClassID, std::streampos Pos );

          //---------------------------------------------------------------------

          const std::multimap< unsigned long, IndexPool::ObjectStrIndex * , std::less< unsigned long > > & getObjectStrIndexMapRef() const;

          //---------------------------------------------------------------------

          int getObjectStrIndexIterator(  ObjectStrIndexIterator *& prObjectStrIndexIterators,

                                          unsigned long ulClassID,

                                          const std::string & rsIndexName ) const;

          //---------------------------------------------------------------------

          int makeObjectStrIndex( const std::string & rsPathName,

                                  unsigned long ulClassID,

                                  const std::string & rsIndexName,

                                  bool bUnique );

          //---------------------------------------------------------------------

          int getObjectStrIndex( ObjectStrIndex *& prRetVal,

                                 unsigned long ulClassID,

                                 const std::string & rsIndexName );

          //---------------------------------------------------------------------

          int removeObjectStrIndex( unsigned long ulClassID,

                                    const std::string & rsIndexName );

          //---------------------------------------------------------------------

          int isIndexFree( unsigned long ulClassID,

                           const ObjID & rObjID,

                           const std::string & rsIndexName,

                           const std::string & rsIndex ) const;

          //---------------------------------------------------------------------

          int reserveObjStrIdTuple( unsigned long ulClassID,

                                    const std::string & rsIndexName,

                                    const ObjStrIdTuple & rIndexTuple );

          //---------------------------------------------------------------------

          int releaseObjStrIdTuple( unsigned long ulClassID,

                                    const std::string & rsIndexName,

                                    const NUM_PTR ipReservingComunicatorTrx );

          //---------------------------------------------------------------------

          int insertObjStrIdTuple( unsigned long ulClassID,

                                   const std::string & rsIndexName,

                                   const ObjStrIdTuple & rIndexTuple );

          //---------------------------------------------------------------------

          int removeObjStrIdTuple( unsigned long ulClassID,

                                   const std::string & rsIndexName,

                                   const ObjID & rObjID,

                                   NUM_PTR ipReservingComunicatorTrx = 0 );

          //---------------------------------------------------------------------


        protected:

          //---------------------------------------------------------------------

          void copyMapsFrom( const SchemaIndex & rT );

          //---------------------------------------------------------------------

          void deleteAllTableIndexValues();

          //---------------------------------------------------------------------


        public:

          //============== Operatoren

          //---------------------------------------------------------------------

          IndexPool::SchemaIndex & operator= ( const SchemaIndex & rT );

          //---------------------------------------------------------------------

      };


      //-----------------------------------------------------------------------

      // <<<<<<<<<<<<<<<<<<<<<<<<< SchemaIndex <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

      //-----------------------------------------------------------------------


  // ============================================================================

  //---------------------------- IndexPool --------------------------------------

    protected:

      //============== Attribute

      //-----------------------------------------------------------------------

      #if defined (__PTHREADS)

        EuPCriticalSection  m_LocalCriticalSection;

      #else

        eut::CriticalSection  m_LocalCriticalSection;

      #endif

      //-----------------------------------------------------------------------

      std::map< std::string, SchemaIndex * , std::less< std::string > > m_SchemaIndexMap;

      //-----------------------------------------------------------------------


    public:

      //============== De- und Konstruktor

      //-----------------------------------------------------------------------

      IndexPool();

      //-----------------------------------------------------------------------

      IndexPool( const IndexPool & rT );

      //-----------------------------------------------------------------------

      virtual ~IndexPool();

      //-----------------------------------------------------------------------


      //============== Methoden

      //-----------------------------------------------------------------------

      virtual int getTableObjIdIndexIterator( TableObjIdIndexIterator *& prTableIterators,

                                              const std::string & rsSchemaName,

                                              unsigned long ulClassID ) const;

      //-----------------------------------------------------------------------

      virtual int isObjIdFree(  const std::string & rsSchemaName,

                                const ObjID & rObjID ) const;

      //-----------------------------------------------------------------------

      virtual int insertDeletedObjID( const std::string & rsSchemaName,

                                      const ObjID & rDeletedObjId );

      //-----------------------------------------------------------------------

      virtual bool isObjIdDeleted(  const std::string & rsSchemaName,

                                    const ObjID & rObjID ) const;

      //-----------------------------------------------------------------------

      virtual int insertObjIdPosTuple(  const std::string & rsSchemaName,

                                        unsigned long ulClassID,

                                        const ObjIdPosTuple & rIndexTuple );

      //-----------------------------------------------------------------------

      virtual int getObjIdPosTuple( ObjIdPosTuple *& prRetVal,

                                    const std::string & rsSchemaName,

                                    unsigned long ulClassID,

                                    const ObjID & rObjID ) const;

      //-----------------------------------------------------------------------

      virtual int removeObjId( const std::string & rsSchemaName,

                               unsigned long ulClassID,

                               const ObjID & rObjID );

      //-----------------------------------------------------------------------

      virtual int getObjectStrIndexIterator(  ObjectStrIndexIterator *& prObjectStrIndexIterators,

                                              const std::string & rsSchemaName,

                                              unsigned long ulClassID,

                                              const std::string & rsIndexName ) const;

      //-----------------------------------------------------------------------

      virtual int isIndexFree( const std::string & rsSchemaName,

                               unsigned long ulClassID,

                               const ObjID & rObjID,

                               const std::string & rsIndexName,

                               const std::string & rsIndex ) const;

      //-----------------------------------------------------------------------

      int reserveObjStrIdTuple( const std::string & rsSchemaName,

                                unsigned long ulClassID,

                                const std::string & rsIndexName,

                                const ObjStrIdTuple & rIndexTuple );

      //-----------------------------------------------------------------------

      int releaseObjStrIdTuple( const std::string & rsSchemaName,

                                unsigned long ulClassID,

                                const std::string & rsIndexName,

                                const NUM_PTR ipReservingComunicatorTrx );

      //-----------------------------------------------------------------------

      virtual int insertObjStrIdTuple(  const std::string & rsSchemaName,

                                        unsigned long ulClassID,

                                        const std::string & rsIndexName,

                                        const ObjStrIdTuple & rIndexTuple );

      //-----------------------------------------------------------------------

      virtual int removeObjStrIdTuple( const std::string & rsSchemaName,

                                       unsigned long ulClassID,

                                       const std::string & rsIndexName,

                                       const ObjID & rObjID,

                                       NUM_PTR ipReservingComunicatorTrx = 0 );

      //-----------------------------------------------------------------------

      void deleteAllSchemaIndexValues();

      //-----------------------------------------------------------------------


    protected:

      //============== Methoden

      //-----------------------------------------------------------------------

      void copyMapFrom( const IndexPool & rT );

      //-----------------------------------------------------------------------

      int _removeSchemaIndex( const std::string & rsSchemaName );

      //-----------------------------------------------------------------------

      virtual bool _existsSchemaIndex( const std::string & rsSchemaName ) const;

      //-----------------------------------------------------------------------

      virtual int _getSchemaIndex( SchemaIndex *& prRetVal,

                                   const std::string & rsSchemaName ) const;

      //-----------------------------------------------------------------------

      virtual int _getTableObjIdIndexIterator(  TableObjIdIndexIterator *& prTableIterators,

                                                const std::string & rsSchemaName,

                                                unsigned long ulClassID ) const;

      //-----------------------------------------------------------------------

      virtual int _makeTableObjIdIndex( const std::string & rsSchemaName,

                                        const std::string & rsTablePathName,

                                        unsigned long ulClassID );

      //-----------------------------------------------------------------------

      virtual int _getTableObjIdIndex(  TableObjIdIndex *& prRetVal,

                                        const std::string & rsSchemaName,

                                        unsigned long ulClassID ) const;

      //-----------------------------------------------------------------------

      virtual int _getObjectStrIndexIterator( ObjectStrIndexIterator *& prObjStrIterators,

                                              const std::string & rsSchemaName,

                                              unsigned long ulClassID,

                                              const std::string & rsIndexName ) const;

      //-----------------------------------------------------------------------

      virtual int _makeObjectStrIndex( const std::string & rsSchemaName,

                                       const std::string & rsTablePathName,

                                       unsigned long ulClassID,

                                       const std::string & rsIndexName,

                                       bool bUnique );

      //-----------------------------------------------------------------------

      virtual int _getObjectStrIndex( ObjectStrIndex *& prRetVal,

                                      const std::string & rsSchemaName,

                                      unsigned long ulClassID,

                                      const std::string & rsIndexName ) const;

      //-----------------------------------------------------------------------

      virtual int _isObjIdFree( const std::string & rsSchemaName,

                                unsigned long ulClassID,

                                const ObjID & rObjID ) const;

      //-----------------------------------------------------------------------

      virtual int _insertDeletedObjID(  const std::string & rsSchemaName,

                                        const ObjID & rDeletedObjId );

      //-----------------------------------------------------------------------

      virtual bool _isObjIdDeleted( const std::string & rsSchemaName,

                                    const ObjID & rObjID ) const;

      //-----------------------------------------------------------------------

      virtual int _insertObjIdPosTuple( const std::string & rsSchemaName,

                                        unsigned long ulClassID,

                                        const ObjIdPosTuple & rIndexTuple );

      //-----------------------------------------------------------------------

      virtual int _insertObjStrIdTuple( const std::string & rsSchemaName,

                                        unsigned long ulClassID,

                                        const std::string & rsIndexName,

                                        const ObjStrIdTuple & rIndexTuple );

      //-----------------------------------------------------------------------

      virtual int _getObjIdPosTuple(  ObjIdPosTuple *& prRetVal,

                                      const std::string & rsSchemaName,

                                      unsigned long ulClassID,

                                      const ObjID & rObjID ) const;

      //-----------------------------------------------------------------------

      virtual int _insertFreeObjIDPos(  const std::string & rsSchemaName,

                                        unsigned long ulClassID,

                                        std::streampos Pos );

      //-----------------------------------------------------------------------

      virtual int _getFreeObjIDPos( std::streampos & rPos,

                                    const std::string & rsSchemaName,

                                    unsigned long ulClassID ) const;

      //-----------------------------------------------------------------------

      virtual int _removeFreeObjIDPos(  const std::string & rsSchemaName,

                                        unsigned long ulClassID,

                                        std::streampos Pos );

      //-----------------------------------------------------------------------

      void _deleteAllSchemaIndexValues();

      //-----------------------------------------------------------------------


    public:

      //============== Operatoren

      //-----------------------------------------------------------------------

      IndexPool & operator= ( const IndexPool & rT );

      //-----------------------------------------------------------------------

  };


  // ============================================================================


  class __glo_export_dll RealIndexPool : public IndexPool

  {

    private:

      //============== Attribute

      //-----------------------------------------------------------------------

      WatchNotifyManager * m_pWatchNotifyManager;

      //-----------------------------------------------------------------------

      int m_iActions;

      //-----------------------------------------------------------------------


    public:

      //============== De- und Konstruktor

      //-----------------------------------------------------------------------

      RealIndexPool();

      //-----------------------------------------------------------------------

      RealIndexPool( const RealIndexPool & rT );

      //-----------------------------------------------------------------------

      virtual ~RealIndexPool();

      //-----------------------------------------------------------------------


      //============== Methoden

      //-----------------------------------------------------------------------

      std::size_t getNumberOfClassInfos( const SchemaInterface & rSchemaInterface ) const;

      //-----------------------------------------------------------------------

      std::size_t getNumberOfIndexes( const SchemaInterface & rSchemaInterface ) const;

      //-----------------------------------------------------------------------

      void setWatchNotifyManager( WatchNotifyManager * pWatchNotifyManager );

      //-----------------------------------------------------------------------

      int removeSchemaIndex( const std::string & rsSchemaName );

      //-----------------------------------------------------------------------

      int readIndexes( const SchemaInterface & rSchemaInterface );

      //-----------------------------------------------------------------------

      int reindex( const SchemaInterface & rSchemaInterface );

      //-----------------------------------------------------------------------

      int reindex( const SchemaInterface & rSchemaInterface, int iActions );

      //-----------------------------------------------------------------------

      int writeIndexes( const SchemaInterface & rSchemaInterface );

      //-----------------------------------------------------------------------

      int writeIndexes( const SchemaInterface & rSchemaInterface, int iActions );

      //-----------------------------------------------------------------------

      int reindexObjIDIndexes( const SchemaInterface & rSchemaInterface );

      //-----------------------------------------------------------------------

      int reindexObjStrIndexes( const SchemaInterface & rSchemaInterface );

      //-----------------------------------------------------------------------

      int writeObjIDIndexes( const SchemaInterface & rSchemaInterface ) const;

      //-----------------------------------------------------------------------

      int writeObjStrIndexes( const SchemaInterface & rSchemaInterface ) const;

      //-----------------------------------------------------------------------

      virtual bool existsSchemaIndex( const std::string & rsSchemaName ) const;

      //-----------------------------------------------------------------------

      virtual int insertFreeObjIDPos( const std::string & rsSchemaName,

                                      unsigned long ulClassID,

                                      std::streampos Pos );

      //-----------------------------------------------------------------------

      virtual int getFreeObjIDPos( std::streampos & rPos,

                                   const std::string & rsSchemaName,

                                   unsigned long ulClassID ) const;

      //-----------------------------------------------------------------------

      virtual int removeFreeObjIDPos( const std::string & rsSchemaName,

                                      unsigned long ulClassID,

                                      std::streampos Pos );

      //-----------------------------------------------------------------------

      void notifyIndexReadWrite( TdWatchNotifyMode iMode,

                                 const std::string & rsSchemaName,

                                 const ObjID & rObjID,

                                 int iFraction,

                                 int iActions );

      //-----------------------------------------------------------------------


    protected:

      //============== Methoden

      //-----------------------------------------------------------------------

      int _reindexObjIDIndexes( const SchemaInterface & rSchemaInterface );

      //-----------------------------------------------------------------------

      int _reindexObjStrIndexes( const SchemaInterface & rSchemaInterface );

      //-----------------------------------------------------------------------

      int _writeObjIDIndexes( const SchemaInterface & rSchemaInterface ) const;

      //-----------------------------------------------------------------------

      int _writeObjStrIndexes( const SchemaInterface & rSchemaInterface ) const;

      //-----------------------------------------------------------------------

      int _writeObjIDIndexes( const SchemaIndex & rSchemaIndex ) const;

      //-----------------------------------------------------------------------

      int _writeObjStrIndexes( const SchemaIndex & rSchemaIndex ) const;

      //-----------------------------------------------------------------------

      int _readObjIDIndexes( const SchemaInterface & rSchemaInterface );

      //-----------------------------------------------------------------------

      int _readObjStrIndexes( const SchemaInterface & rSchemaInterface );

      //-----------------------------------------------------------------------

      int _createObjIDIndexFromTable( const SchemaInterface & rSchemaInterface,

                                      const ClassInfoAttribute & rClassInfoAttribute );

      //-----------------------------------------------------------------------

      int _createObjStrIndexFromTables( const SchemaInterface & rSchemaInterface,

                                        const ClassInfoIndex & rClassInfoIndex );

      //-----------------------------------------------------------------------

      int _getIndexString(  std::string & rsRetValIndex,

                            const std::vector< eut::LanguageFunctions::EnLanguageKey > & rLanguageKeys,

                            bool bCaseSensitive,

                            const SchemaInterface & rSchemaInterface,

                            unsigned long ulClassID,

                            const ObjID & rObjID,

                            const ClassInfoIndex::IndexAttributeItem & rIndexAttributeItem );

      //-----------------------------------------------------------------------


    public:

      //============== Operatoren

      //-----------------------------------------------------------------------

      RealIndexPool & operator= ( const RealIndexPool & rT );

      //-----------------------------------------------------------------------

  };


  // ============================================================================


  class TransactionIndexPool : public IndexPool

  {

    public:

      //============== De- und Konstruktor

      //-----------------------------------------------------------------------

      TransactionIndexPool();

      //-----------------------------------------------------------------------


      TransactionIndexPool( const TransactionIndexPool & rT );

      TransactionIndexPool( const IndexPool & rT );

      //-----------------------------------------------------------------------

      virtual ~TransactionIndexPool();

      //-----------------------------------------------------------------------


      //============== Methoden

      //-----------------------------------------------------------------------

      int insertTransactionDeletedObjID( const std::string & rsSchemaName,

                                         const ObjID & rDeletedObjId );

      //-----------------------------------------------------------------------

      int removeTransactionDeletedObjID( const std::string & rsSchemaName,

                                         const ObjID & rDeletedObjId );

      //-----------------------------------------------------------------------


    public:

      //============== Operatoren

      //-----------------------------------------------------------------------


      TransactionIndexPool & operator= ( const TransactionIndexPool & rT );

      TransactionIndexPool & operator= ( const IndexPool & rT );

      //-----------------------------------------------------------------------

  };


  // ============================================================================

  #ifdef _MSC_VER

    /* 'Bezeichner': Klasse 'Typ' benötigt eine DLL-Schnittstelle, die von... */

    #pragma warning( default : 4251 )

  #endif

  //---------------------------------------------------------------------------

} // namespace glo

#endif

EuCriticalSection.h
Header für CriticalSection

NUM_PTR
long long NUM_PTR
Definition EuDef_NULL_PTR.h:93

EuPCriticalSection.h
Header für EuPCriticalSection

GloClassInfoAttribute.h
Header für ClassInfoAttribute und ClassInfoAttribute::Type

GloClassInfoIndex.h
Header für ClassInfoIndex und ClassInfoIndex::IndexAttributeItem

GloObjID.h
Header für ObjID

GloTypes.h
Für jede Bibliothek, hier 'GlobalObjects' gibt es eine Typen-Datei.

__glo_export_dll
#define __glo_export_dll
Definition GloTypes.h:63

GloWatchNotifyManager.h
Header für WatchNotifyManager    WatchNotifyManager::NotifyInfo   WatchNotifyManager::NotifyObjInfo  ...

EuPCriticalSection
Ist ein Mutex, welcher über sein Lock-Modus abgefragt werden kann. Siehe isLocked().
Definition EuPCriticalSection.h:89

eut::CriticalSection
Ist ein Mutex, welcher über sein Lock-Modus abgefragt werden kann. Siehe isLocked().
Definition EuCriticalSection.h:94

glo::ClassInfoAttribute
In Objekten dieser Klasse sind die Information für GlobalObjects, wie ein persistentes Klassenattribu...
Definition GloClassInfoAttribute.h:76

glo::ClassInfoIndex::IndexAttributeItem
Information für den Index aus welcher Klasse welches Attribut mit wie viel Zeichen zum Index gehört.
Definition GloClassInfoIndex.h:104

glo::ClassInfoIndex
In Objekten dieser Klasse sind die Information für GlobalObjects, wie ein Index aufgebaut ist.
Definition GloClassInfoIndex.h:78

glo::IndexPool::DeletedObjIdTuple
Klasse um gelöschte Objekte im IndexPool::SchemaIndex zu verwalten.
Definition GloIndexPool.h:224

glo::IndexPool::DeletedObjIdTuple::toString
std::string toString() const

glo::IndexPool::DeletedObjIdTuple::m_iDelCounter
int m_iDelCounter
Definition GloIndexPool.h:263

glo::IndexPool::DeletedObjIdTuple::m_ObjID
ObjID m_ObjID
Definition GloIndexPool.h:237

glo::IndexPool::DeletedObjIdTuple::~DeletedObjIdTuple
virtual ~DeletedObjIdTuple()

glo::IndexPool::DeletedObjIdTuple::DeletedObjIdTuple
DeletedObjIdTuple()

glo::IndexPool::DeletedObjIdTuple::DeletedObjIdTuple
DeletedObjIdTuple(const DeletedObjIdTuple &rT)

glo::IndexPool::DeletedObjIdTuple::DeletedObjIdTuple
DeletedObjIdTuple(const ObjID &rObjID, int iDelCounter)

glo::IndexPool::ObjIdPosTuple
Klasse um Objekte im IndexPool::TableObjIdIndex zu verwalten.
Definition GloIndexPool.h:417

glo::IndexPool::ObjIdPosTuple::ObjIdPosTuple
ObjIdPosTuple()

glo::IndexPool::ObjIdPosTuple::ObjIdPosTuple
ObjIdPosTuple(const ObjIdPosTuple &rT)

glo::IndexPool::ObjIdPosTuple::toString
std::string toString() const

glo::IndexPool::ObjIdPosTuple::m_FilePosition
std::streampos m_FilePosition
Definition GloIndexPool.h:441

glo::IndexPool::ObjIdPosTuple::m_ObjID
ObjID m_ObjID
Definition GloIndexPool.h:430

glo::IndexPool::ObjIdPosTuple::~ObjIdPosTuple
virtual ~ObjIdPosTuple()

glo::IndexPool::ObjIdPosTuple::ObjIdPosTuple
ObjIdPosTuple(const ObjID &rObjID, std::streampos FilePosition)

glo::IndexPool::ObjStrIdTuple
Klasse um Objekte im IndexPool::ObjectStrIndex zu verwalten.
Definition GloIndexPool.h:600

glo::IndexPool::ObjStrIdTuple::m_ObjID
ObjID m_ObjID
Definition GloIndexPool.h:632

glo::IndexPool::ObjStrIdTuple::toString
std::string toString() const

glo::IndexPool::ObjStrIdTuple::setValues
void setValues(const std::string &rsIndex, const ObjID &rObjID, NUM_PTR ipReservingComunicatorTrx=0)

glo::IndexPool::ObjStrIdTuple::ObjStrIdTuple
ObjStrIdTuple(const ObjStrIdTuple &rT)

glo::IndexPool::ObjStrIdTuple::setIndex
void setIndex(const std::string &rsIndex)

glo::IndexPool::ObjStrIdTuple::m_ipReservingComunicatorTrx
NUM_PTR m_ipReservingComunicatorTrx
Definition GloIndexPool.h:647

glo::IndexPool::ObjStrIdTuple::ObjStrIdTuple
ObjStrIdTuple()

glo::IndexPool::ObjStrIdTuple::~ObjStrIdTuple
virtual ~ObjStrIdTuple()

glo::IndexPool::ObjStrIdTuple::setObjID
void setObjID(const ObjID &rObjID)

glo::IndexPool::ObjStrIdTuple::getReservingComunicatorTrx
NUM_PTR getReservingComunicatorTrx() const

glo::IndexPool::ObjStrIdTuple::setReservingComunicatorTrx
void setReservingComunicatorTrx(NUM_PTR ipReservingComunicatorTrx)

glo::IndexPool::ObjStrIdTuple::getObjID
ObjID getObjID() const

glo::IndexPool::ObjStrIdTuple::ObjStrIdTuple
ObjStrIdTuple(const std::string &rsIndex, const ObjID &rObjID, NUM_PTR ipReservingComunicatorTrx=0)

glo::IndexPool::ObjStrIdTuple::m_sIndex
std::string m_sIndex
Definition GloIndexPool.h:621

glo::IndexPool::ObjStrIdTuple::getIndex
std::string getIndex() const

glo::IndexPool::ObjectStrIndex
Verwaltet die einzelnen String-Indizes einer Klasse. Wenn dieses ein Unique-Index ist,...
Definition GloIndexPool.h:1686

glo::IndexPool::ObjectStrIndex::m_ObjIdIndexMap
std::map< ObjID, ObjStrIdTuple *, std::less< ObjID > > m_ObjIdIndexMap
Definition GloIndexPool.h:1831

glo::IndexPool::ObjectStrIndex::m_NonUniqueIndexMultiMapIterator
std::multimap< std::string, ObjStrIdTuple * >::iterator m_NonUniqueIndexMultiMapIterator
Definition GloIndexPool.h:1818

glo::IndexPool::ObjectStrIndex::m_UniqueIndexMapIterator
std::map< std::string, ObjStrIdTuple * >::iterator m_UniqueIndexMapIterator
Definition GloIndexPool.h:1768

glo::IndexPool::ObjectStrIndex::getIndexName
const std::string & getIndexName() const

glo::IndexPool::ObjectStrIndex::getNonUniqueIndexMapRef
const std::multimap< std::string, IndexPool::ObjStrIdTuple *, std::less< std::string > > & getNonUniqueIndexMapRef() const

glo::IndexPool::ObjectStrIndex::m_UniqueIndexMap
std::map< std::string, ObjStrIdTuple *, std::less< std::string > > m_UniqueIndexMap
Definition GloIndexPool.h:1757

glo::IndexPool::ObjectStrIndex::isIndexFree
bool isIndexFree(const std::string &rsIndex, const ObjID &rObjID) const

glo::IndexPool::ObjectStrIndex::getObjIdIndexMapRef
const std::map< ObjID, IndexPool::ObjStrIdTuple *, std::less< ObjID > > & getObjIdIndexMapRef() const

glo::IndexPool::ObjectStrIndex::ObjectStrIndex
ObjectStrIndex()

glo::IndexPool::ObjectStrIndex::getPathName
const std::string & getPathName() const

glo::IndexPool::ObjectStrIndex::isObjIdAlreadyAvailable
bool isObjIdAlreadyAvailable(const ObjID &rObjID) const

glo::IndexPool::ObjectStrIndex::isUnique
bool isUnique() const

glo::IndexPool::ObjectStrIndex::getClassID
unsigned long getClassID() const

glo::IndexPool::ObjectStrIndex::~ObjectStrIndex
virtual ~ObjectStrIndex()

glo::IndexPool::ObjectStrIndex::getObjStrIdTuple
IndexPool::ObjStrIdTuple * getObjStrIdTuple(const ObjID &rObjID)

glo::IndexPool::ObjectStrIndex::copyMapsFrom
void copyMapsFrom(const ObjectStrIndex &rT)

glo::IndexPool::ObjectStrIndex::m_sIndexName
std::string m_sIndexName
Definition GloIndexPool.h:1732

glo::IndexPool::ObjectStrIndex::m_ReservedIndexMultiMap
std::multimap< std::string, ObjStrIdTuple *, std::less< std::string > > m_ReservedIndexMultiMap
Definition GloIndexPool.h:1796

glo::IndexPool::ObjectStrIndex::ObjectStrIndex
ObjectStrIndex(const std::string &rsPathName, unsigned long ulClassID, const std::string &rsIndexName, bool bUnique)

glo::IndexPool::ObjectStrIndex::m_strPathName
std::string m_strPathName
Definition GloIndexPool.h:1706

glo::IndexPool::ObjectStrIndex::deleteAllIndexValues
void deleteAllIndexValues()

glo::IndexPool::ObjectStrIndex::ObjectStrIndex
ObjectStrIndex(const ObjectStrIndex &rT)

glo::IndexPool::ObjectStrIndex::m_NonUniqueIndexMultiMap
std::multimap< std::string, ObjStrIdTuple *, std::less< std::string > > m_NonUniqueIndexMultiMap
Definition GloIndexPool.h:1807

glo::IndexPool::ObjectStrIndex::getUniqueIndexMapRef
const std::map< std::string, IndexPool::ObjStrIdTuple *, std::less< std::string > > & getUniqueIndexMapRef() const

glo::IndexPool::ObjectStrIndex::releaseObjStrIdTuple
void releaseObjStrIdTuple(const NUM_PTR ipReservingComunicatorTrx)

glo::IndexPool::ObjectStrIndex::removeObjStrIdTuple
int removeObjStrIdTuple(const ObjID &rObjID, bool bDelete, NUM_PTR ipReservingComunicatorTrx=0)

glo::IndexPool::ObjectStrIndex::reserveObjStrIdTuple
void reserveObjStrIdTuple(const ObjStrIdTuple &rIndexTuple)

glo::IndexPool::ObjectStrIndex::removeObjStrIdTuple
int removeObjStrIdTuple(const ObjID &rObjID, NUM_PTR ipReservingComunicatorTrx=0)

glo::IndexPool::ObjectStrIndex::m_ulClassID
unsigned long m_ulClassID
Definition GloIndexPool.h:1719

glo::IndexPool::ObjectStrIndex::insertObjStrIdTuple
int insertObjStrIdTuple(const ObjStrIdTuple &rIndexTuple)

glo::IndexPool::ObjectStrIndex::getObjStrIdTuple
IndexPool::ObjStrIdTuple * getObjStrIdTuple(EnSeekMode eMode)

glo::IndexPool::ObjectStrIndex::m_bUnique
bool m_bUnique
Definition GloIndexPool.h:1746

glo::IndexPool::ObjectStrIndexIterator
Hat einen Zeiger auf einen ObjectStrIndex und ermöglicht das iterieren durch diesen Index....
Definition GloIndexPool.h:2497

glo::IndexPool::ObjectStrIndexIterator::m_pObjectStrIndex
ObjectStrIndex * m_pObjectStrIndex
Definition GloIndexPool.h:2514

glo::IndexPool::ObjectStrIndexIterator::ObjectStrIndexIterator
ObjectStrIndexIterator(const ObjectStrIndexIterator &rT)

glo::IndexPool::ObjectStrIndexIterator::inObjectStrIndex
bool inObjectStrIndex(const ObjID &rObjID)

glo::IndexPool::ObjectStrIndexIterator::valueMatchesComparisonFilter
bool valueMatchesComparisonFilter(const std::string &rsSearchIndex, IndexComparisionFilter &rIndexComparisionFilter) const

glo::IndexPool::ObjectStrIndexIterator::setNearestObject
bool setNearestObject(const std::string &rsIndex)

glo::IndexPool::ObjectStrIndexIterator::~ObjectStrIndexIterator
~ObjectStrIndexIterator()

glo::IndexPool::ObjectStrIndexIterator::setFilter
void setFilter(IndexFilter *pIndexFilter)

glo::IndexPool::ObjectStrIndexIterator::getSearchModeAndSearchIndex
int getSearchModeAndSearchIndex(std::string &rsSearchIndex, const std::string rsSourceIndex) const

glo::IndexPool::ObjectStrIndexIterator::setNearestObjectInMultiMap
bool setNearestObjectInMultiMap(std::multimap< std::string, ObjStrIdTuple * >::const_iterator &rIterator, const std::string &rsIndex)

glo::IndexPool::ObjectStrIndexIterator::getObjStrIdTupleList
int getObjStrIdTupleList(std::list< ObjStrIdTuple > &rRetVal, const std::string &rsRangeStartIndex, const std::string &rsRangeEndIndex) const

glo::IndexPool::ObjectStrIndexIterator::setFilter
void setFilter(const std::string &rsIndexFilterValue, EnComparisionOp eComparisionOp)

glo::IndexPool::ObjectStrIndexIterator::getObjStrIdTuple
int getObjStrIdTuple(ObjStrIdTuple &rRetVal, EnSeekMode eMode)

glo::IndexPool::ObjectStrIndexIterator::m_pLastObjectStrIndexItem
ObjStrIdTuple * m_pLastObjectStrIndexItem
Definition GloIndexPool.h:2530

glo::IndexPool::ObjectStrIndexIterator::valueMatchesIndexFilter
bool valueMatchesIndexFilter(const std::string &rsSearchIndex, IndexFilter &rIndexFilter) const

glo::IndexPool::ObjectStrIndexIterator::setCurrentObject
int setCurrentObject(const ObjID &rObjID)

glo::IndexPool::ObjectStrIndexIterator::getClassID
unsigned long getClassID() const

glo::IndexPool::ObjectStrIndexIterator::removeFilter
void removeFilter()

glo::IndexPool::ObjectStrIndexIterator::setFilter
void setFilter(const std::string &rsIndexFilterValue)

glo::IndexPool::ObjectStrIndexIterator::inObjectStrIndex
bool inObjectStrIndex(const std::string &rsIndex)

glo::IndexPool::ObjectStrIndexIterator::setFilter
void setFilter(const std::string &rsRangeStartIndex, const std::string &rsRangeEndIndex)

glo::IndexPool::ObjectStrIndexIterator::getObjectStrIndexSize
std::size_t getObjectStrIndexSize() const

glo::IndexPool::ObjectStrIndexIterator::ObjectStrIndexIterator
ObjectStrIndexIterator()

glo::IndexPool::ObjectStrIndexIterator::setNearestObjectInMap
bool setNearestObjectInMap(std::map< std::string, ObjStrIdTuple * >::const_iterator &rIterator, const std::string &rsIndex)

glo::IndexPool::ObjectStrIndexIterator::getObjStrIdTupleList
int getObjStrIdTupleList(std::list< ObjStrIdTuple > &rRetVal, const std::string &rsIndex, EnQueryType eQuerryType) const

glo::IndexPool::ObjectStrIndexIterator::m_pIndexFilter
IndexFilter * m_pIndexFilter
Definition GloIndexPool.h:2541

glo::IndexPool::ObjectStrIndexIterator::valueMatchesRangeFilter
bool valueMatchesRangeFilter(const std::string &rsSearchIndex, IndexRangeFilter &rIndexRangeFilter) const

glo::IndexPool::ObjectStrIndexIterator::ObjectStrIndexIterator
ObjectStrIndexIterator(ObjectStrIndex *pObjectStrIndex)

glo::IndexPool::ObjectStrIndexIterator::getObjStrIdTupleList
int getObjStrIdTupleList(std::list< ObjStrIdTuple > &rRetVal, const std::string &rsIndex, EnComparisionOp eComparisionOp) const

glo::IndexPool::ObjectStrIndexIterator::setPosition
int setPosition(std::size_t nPosition)

glo::IndexPool::SchemaIndex
Ist die Indexverwalterklasse für ein Schema bzw. eine Datenbank.
Definition GloIndexPool.h:3192

glo::IndexPool::SchemaIndex::removeObjStrIdTuple
int removeObjStrIdTuple(unsigned long ulClassID, const std::string &rsIndexName, const ObjID &rObjID, NUM_PTR ipReservingComunicatorTrx=0)

glo::IndexPool::SchemaIndex::insertObjIdPosTuple
int insertObjIdPosTuple(unsigned long ulClassID, const ObjIdPosTuple &rIndexTuple)

glo::IndexPool::SchemaIndex::isObjIdDeleted
bool isObjIdDeleted(const ObjID &rObjID) const

glo::IndexPool::SchemaIndex::m_ObjectStrIndexMap
std::multimap< unsigned long, ObjectStrIndex *, std::less< unsigned long > > m_ObjectStrIndexMap
Definition GloIndexPool.h:3235

glo::IndexPool::SchemaIndex::getObjectStrIndex
int getObjectStrIndex(ObjectStrIndex *&prRetVal, unsigned long ulClassID, const std::string &rsIndexName)

glo::IndexPool::SchemaIndex::insertTransactionDeletedObjID
int insertTransactionDeletedObjID(const ObjID &rDeletedObjId)

glo::IndexPool::SchemaIndex::getObjIdPosTuple
int getObjIdPosTuple(ObjIdPosTuple *&prRetVal, unsigned long ulClassID, const ObjID &rObjID) const

glo::IndexPool::SchemaIndex::getSchemaName
std::string getSchemaName() const

glo::IndexPool::SchemaIndex::insertFreeObjIDPos
int insertFreeObjIDPos(unsigned long ulClassID, std::streampos Pos)

glo::IndexPool::SchemaIndex::removeObjId
int removeObjId(unsigned long ulClassID, const ObjID &rObjID)

glo::IndexPool::SchemaIndex::reserveObjStrIdTuple
int reserveObjStrIdTuple(unsigned long ulClassID, const std::string &rsIndexName, const ObjStrIdTuple &rIndexTuple)

glo::IndexPool::SchemaIndex::removeObjectStrIndex
int removeObjectStrIndex(unsigned long ulClassID, const std::string &rsIndexName)

glo::IndexPool::SchemaIndex::releaseObjStrIdTuple
int releaseObjStrIdTuple(unsigned long ulClassID, const std::string &rsIndexName, const NUM_PTR ipReservingComunicatorTrx)

glo::IndexPool::SchemaIndex::getTableObjIdIndexIterator
int getTableObjIdIndexIterator(TableObjIdIndexIterator *&prTableIterators, unsigned long ulClassID) const

glo::IndexPool::SchemaIndex::removeFreeObjIDPos
int removeFreeObjIDPos(unsigned long ulClassID, std::streampos Pos)

glo::IndexPool::SchemaIndex::m_TableObjIdIndexMap
std::map< unsigned long, TableObjIdIndex *, std::less< unsigned long > > m_TableObjIdIndexMap
Definition GloIndexPool.h:3220

glo::IndexPool::SchemaIndex::getFreeObjIDPos
int getFreeObjIDPos(std::streampos &rPos, unsigned long ulClassID) const

glo::IndexPool::SchemaIndex::getTableObjIdIndex
int getTableObjIdIndex(TableObjIdIndex *&prRetVal, unsigned long ulClassID) const

glo::IndexPool::SchemaIndex::copyMapsFrom
void copyMapsFrom(const SchemaIndex &rT)

glo::IndexPool::SchemaIndex::SchemaIndex
SchemaIndex()

glo::IndexPool::SchemaIndex::m_sSchemaName
std::string m_sSchemaName
Definition GloIndexPool.h:3205

glo::IndexPool::SchemaIndex::removeTransactionDeletedObjID
int removeTransactionDeletedObjID(const ObjID &rDeletedObjId)

glo::IndexPool::SchemaIndex::insertObjStrIdTuple
int insertObjStrIdTuple(unsigned long ulClassID, const std::string &rsIndexName, const ObjStrIdTuple &rIndexTuple)

glo::IndexPool::SchemaIndex::insertDeletedObjID
int insertDeletedObjID(const ObjID &rDeletedObjId)

glo::IndexPool::SchemaIndex::SchemaIndex
SchemaIndex(const SchemaIndex &rT)

glo::IndexPool::SchemaIndex::makeObjectStrIndex
int makeObjectStrIndex(const std::string &rsPathName, unsigned long ulClassID, const std::string &rsIndexName, bool bUnique)

glo::IndexPool::SchemaIndex::m_DeletedObjIdMap
std::map< ObjID, ObjID *, std::less< ObjID > > m_DeletedObjIdMap
Definition GloIndexPool.h:3250

glo::IndexPool::SchemaIndex::~SchemaIndex
~SchemaIndex()

glo::IndexPool::SchemaIndex::getObjectStrIndexIterator
int getObjectStrIndexIterator(ObjectStrIndexIterator *&prObjectStrIndexIterators, unsigned long ulClassID, const std::string &rsIndexName) const

glo::IndexPool::SchemaIndex::makeTableObjIdIndex
int makeTableObjIdIndex(const std::string &rsPathName, unsigned long ulClassID)

glo::IndexPool::SchemaIndex::deleteAllTableIndexValues
void deleteAllTableIndexValues()

glo::IndexPool::SchemaIndex::SchemaIndex
SchemaIndex(const std::string &rstrName)

glo::IndexPool::SchemaIndex::m_TransactionDeletedObjIdMap
std::map< ObjID, DeletedObjIdTuple *, std::less< ObjID > > m_TransactionDeletedObjIdMap
Definition GloIndexPool.h:3274

glo::IndexPool::SchemaIndex::getTableObjIdIndexMapRef
const std::map< unsigned long, IndexPool::TableObjIdIndex *, std::less< unsigned long > > & getTableObjIdIndexMapRef() const

glo::IndexPool::SchemaIndex::removeTableObjIdIndex
int removeTableObjIdIndex(unsigned long ulClassID)

glo::IndexPool::SchemaIndex::isIndexFree
int isIndexFree(unsigned long ulClassID, const ObjID &rObjID, const std::string &rsIndexName, const std::string &rsIndex) const

glo::IndexPool::SchemaIndex::getObjectStrIndexMapRef
const std::multimap< unsigned long, IndexPool::ObjectStrIndex *, std::less< unsigned long > > & getObjectStrIndexMapRef() const

glo::IndexPool::SchemaIndex::isObjIdFree
int isObjIdFree(unsigned long ulClassID, const ObjID &rObjID) const

glo::IndexPool::TableObjIdIndex
Verwaltet die Objekt-IDs (genutzte wie freigegebene) mit deren Position in den jeweiligen Tabellen.
Definition GloIndexPool.h:911

glo::IndexPool::TableObjIdIndex::getPathName
const std::string & getPathName() const

glo::IndexPool::TableObjIdIndex::TableObjIdIndex
TableObjIdIndex(const TableObjIdIndex &rT)

glo::IndexPool::TableObjIdIndex::TableObjIdIndex
TableObjIdIndex()

glo::IndexPool::TableObjIdIndex::getFreeObjIDPos
int getFreeObjIDPos(std::streampos &rPos) const

glo::IndexPool::TableObjIdIndex::m_strPathName
std::string m_strPathName
Definition GloIndexPool.h:926

glo::IndexPool::TableObjIdIndex::m_ulClassID
unsigned long m_ulClassID
Definition GloIndexPool.h:939

glo::IndexPool::TableObjIdIndex::getClassID
unsigned long getClassID() const

glo::IndexPool::TableObjIdIndex::insertFreeObjIDPos
int insertFreeObjIDPos(std::streampos Pos)

glo::IndexPool::TableObjIdIndex::~TableObjIdIndex
virtual ~TableObjIdIndex()

glo::IndexPool::TableObjIdIndex::getObjIDIndexMapRef
const std::map< ObjID, IndexPool::ObjIdPosTuple *, std::less< ObjID > > & getObjIDIndexMapRef() const

glo::IndexPool::TableObjIdIndex::removeObjId
int removeObjId(const ObjID &rObjID)

glo::IndexPool::TableObjIdIndex::copyMapFrom
void copyMapFrom(const TableObjIdIndex &rT)

glo::IndexPool::TableObjIdIndex::getObjIdPosTuple
int getObjIdPosTuple(ObjIdPosTuple *&prRetVal, const ObjID &rObjID) const

glo::IndexPool::TableObjIdIndex::m_FreeObjIDPosMap
std::map< std::streampos, std::streampos, std::less< std::streampos > > m_FreeObjIDPosMap
Definition GloIndexPool.h:964

glo::IndexPool::TableObjIdIndex::m_ObjIDIndexMap
std::map< ObjID, ObjIdPosTuple *, std::less< ObjID > > m_ObjIDIndexMap
Definition GloIndexPool.h:951

glo::IndexPool::TableObjIdIndex::removeAllFreeObjIDPos
void removeAllFreeObjIDPos()

glo::IndexPool::TableObjIdIndex::insertObjIdPosTuple
int insertObjIdPosTuple(const ObjIdPosTuple &rIndexTuple)

glo::IndexPool::TableObjIdIndex::removeFreeObjIDPos
int removeFreeObjIDPos(std::streampos Pos)

glo::IndexPool::TableObjIdIndex::deleteAllIndexValues
void deleteAllIndexValues()

glo::IndexPool::TableObjIdIndex::TableObjIdIndex
TableObjIdIndex(const std::string &rsPathName, unsigned long ulClassID)

glo::IndexPool::TableObjIdIndex::getFreeObjIDPosMapRef
const std::map< std::streampos, std::streampos, std::less< std::streampos > > & getFreeObjIDPosMapRef() const

glo::IndexPool::TableObjIdIndex::isObjIdFree
bool isObjIdFree(const ObjID &rObjID) const

glo::IndexPool::TableObjIdIndexIterator
Hat einen Zeiger auf einen TableObjIdIndex und ermöglicht das iterieren durch diesen Index....
Definition GloIndexPool.h:1315

glo::IndexPool::TableObjIdIndexIterator::getTableObjIdIndexSize
std::size_t getTableObjIdIndexSize() const

glo::IndexPool::TableObjIdIndexIterator::TableObjIdIndexIterator
TableObjIdIndexIterator(TableObjIdIndex *pTableObjIdIndex)

glo::IndexPool::TableObjIdIndexIterator::setWithSubClasses
void setWithSubClasses(bool bWithSubClasses)

glo::IndexPool::TableObjIdIndexIterator::m_pLastTableObjIdIndexItem
ObjIdPosTuple * m_pLastTableObjIdIndexItem
Definition GloIndexPool.h:1346

glo::IndexPool::TableObjIdIndexIterator::getClassID
unsigned long getClassID() const

glo::IndexPool::TableObjIdIndexIterator::setCurrentObject
int setCurrentObject(const ObjID &rObjID)

glo::IndexPool::TableObjIdIndexIterator::setPosition
int setPosition(std::size_t nPosition)

glo::IndexPool::TableObjIdIndexIterator::withSubClasses
bool withSubClasses() const

glo::IndexPool::TableObjIdIndexIterator::~TableObjIdIndexIterator
~TableObjIdIndexIterator()

glo::IndexPool::TableObjIdIndexIterator::TableObjIdIndexIterator
TableObjIdIndexIterator(const TableObjIdIndexIterator &rT)

glo::IndexPool::TableObjIdIndexIterator::setNearestObject
bool setNearestObject(std::map< ObjID, ObjIdPosTuple * >::iterator &rIterator, const ObjID &rObjID)

glo::IndexPool::TableObjIdIndexIterator::m_bWithSubClasses
bool m_bWithSubClasses
Definition GloIndexPool.h:1361

glo::IndexPool::TableObjIdIndexIterator::inObjIdIndex
bool inObjIdIndex(const ObjID &rObjID)

glo::IndexPool::TableObjIdIndexIterator::getObjIdPosTuple
int getObjIdPosTuple(ObjIdPosTuple *&prRetVal, EnSeekMode eMode)

glo::IndexPool::TableObjIdIndexIterator::TableObjIdIndexIterator
TableObjIdIndexIterator()

glo::IndexPool::TableObjIdIndexIterator::setNearestObject
bool setNearestObject(const ObjID &rObjID)

glo::IndexPool::TableObjIdIndexIterator::m_pTableObjIdIndex
TableObjIdIndex * m_pTableObjIdIndex
Definition GloIndexPool.h:1330

glo::IndexPool
IndexPool ist die Basisklasse für den RealIndexPool und den TransactionIndexPool für die einzelnen Tr...
Definition GloIndexPool.h:192

glo::IndexPool::IndexPool
IndexPool(const IndexPool &rT)

glo::IndexPool::m_LocalCriticalSection
eut::CriticalSection m_LocalCriticalSection
Definition GloIndexPool.h:4038

glo::IndexPool::_getTableObjIdIndex
virtual int _getTableObjIdIndex(TableObjIdIndex *&prRetVal, const std::string &rsSchemaName, unsigned long ulClassID) const

glo::IndexPool::isIndexFree
virtual int isIndexFree(const std::string &rsSchemaName, unsigned long ulClassID, const ObjID &rObjID, const std::string &rsIndexName, const std::string &rsIndex) const

glo::IndexPool::_existsSchemaIndex
virtual bool _existsSchemaIndex(const std::string &rsSchemaName) const

glo::IndexPool::reserveObjStrIdTuple
int reserveObjStrIdTuple(const std::string &rsSchemaName, unsigned long ulClassID, const std::string &rsIndexName, const ObjStrIdTuple &rIndexTuple)

glo::IndexPool::_insertObjIdPosTuple
virtual int _insertObjIdPosTuple(const std::string &rsSchemaName, unsigned long ulClassID, const ObjIdPosTuple &rIndexTuple)

glo::IndexPool::copyMapFrom
void copyMapFrom(const IndexPool &rT)

glo::IndexPool::IndexPool
IndexPool()

glo::IndexPool::getObjectStrIndexIterator
virtual int getObjectStrIndexIterator(ObjectStrIndexIterator *&prObjectStrIndexIterators, const std::string &rsSchemaName, unsigned long ulClassID, const std::string &rsIndexName) const

glo::IndexPool::isObjIdDeleted
virtual bool isObjIdDeleted(const std::string &rsSchemaName, const ObjID &rObjID) const

glo::IndexPool::_insertObjStrIdTuple
virtual int _insertObjStrIdTuple(const std::string &rsSchemaName, unsigned long ulClassID, const std::string &rsIndexName, const ObjStrIdTuple &rIndexTuple)

glo::IndexPool::removeObjStrIdTuple
virtual int removeObjStrIdTuple(const std::string &rsSchemaName, unsigned long ulClassID, const std::string &rsIndexName, const ObjID &rObjID, NUM_PTR ipReservingComunicatorTrx=0)

glo::IndexPool::_getObjIdPosTuple
virtual int _getObjIdPosTuple(ObjIdPosTuple *&prRetVal, const std::string &rsSchemaName, unsigned long ulClassID, const ObjID &rObjID) const

glo::IndexPool::_getObjectStrIndexIterator
virtual int _getObjectStrIndexIterator(ObjectStrIndexIterator *&prObjStrIterators, const std::string &rsSchemaName, unsigned long ulClassID, const std::string &rsIndexName) const

glo::IndexPool::getObjIdPosTuple
virtual int getObjIdPosTuple(ObjIdPosTuple *&prRetVal, const std::string &rsSchemaName, unsigned long ulClassID, const ObjID &rObjID) const

glo::IndexPool::insertDeletedObjID
virtual int insertDeletedObjID(const std::string &rsSchemaName, const ObjID &rDeletedObjId)

glo::IndexPool::_makeObjectStrIndex
virtual int _makeObjectStrIndex(const std::string &rsSchemaName, const std::string &rsTablePathName, unsigned long ulClassID, const std::string &rsIndexName, bool bUnique)

glo::IndexPool::getTableObjIdIndexIterator
virtual int getTableObjIdIndexIterator(TableObjIdIndexIterator *&prTableIterators, const std::string &rsSchemaName, unsigned long ulClassID) const

glo::IndexPool::_getTableObjIdIndexIterator
virtual int _getTableObjIdIndexIterator(TableObjIdIndexIterator *&prTableIterators, const std::string &rsSchemaName, unsigned long ulClassID) const

glo::IndexPool::_insertDeletedObjID
virtual int _insertDeletedObjID(const std::string &rsSchemaName, const ObjID &rDeletedObjId)

glo::IndexPool::_makeTableObjIdIndex
virtual int _makeTableObjIdIndex(const std::string &rsSchemaName, const std::string &rsTablePathName, unsigned long ulClassID)

glo::IndexPool::removeObjId
virtual int removeObjId(const std::string &rsSchemaName, unsigned long ulClassID, const ObjID &rObjID)

glo::IndexPool::_insertFreeObjIDPos
virtual int _insertFreeObjIDPos(const std::string &rsSchemaName, unsigned long ulClassID, std::streampos Pos)

glo::IndexPool::isObjIdFree
virtual int isObjIdFree(const std::string &rsSchemaName, const ObjID &rObjID) const

glo::IndexPool::_getFreeObjIDPos
virtual int _getFreeObjIDPos(std::streampos &rPos, const std::string &rsSchemaName, unsigned long ulClassID) const

glo::IndexPool::_removeSchemaIndex
int _removeSchemaIndex(const std::string &rsSchemaName)

glo::IndexPool::_getSchemaIndex
virtual int _getSchemaIndex(SchemaIndex *&prRetVal, const std::string &rsSchemaName) const

glo::IndexPool::insertObjIdPosTuple
virtual int insertObjIdPosTuple(const std::string &rsSchemaName, unsigned long ulClassID, const ObjIdPosTuple &rIndexTuple)

glo::IndexPool::_isObjIdDeleted
virtual bool _isObjIdDeleted(const std::string &rsSchemaName, const ObjID &rObjID) const

glo::IndexPool::_deleteAllSchemaIndexValues
void _deleteAllSchemaIndexValues()

glo::IndexPool::insertObjStrIdTuple
virtual int insertObjStrIdTuple(const std::string &rsSchemaName, unsigned long ulClassID, const std::string &rsIndexName, const ObjStrIdTuple &rIndexTuple)

glo::IndexPool::m_SchemaIndexMap
std::map< std::string, SchemaIndex *, std::less< std::string > > m_SchemaIndexMap
Definition GloIndexPool.h:4050

glo::IndexPool::deleteAllSchemaIndexValues
void deleteAllSchemaIndexValues()

glo::IndexPool::_getObjectStrIndex
virtual int _getObjectStrIndex(ObjectStrIndex *&prRetVal, const std::string &rsSchemaName, unsigned long ulClassID, const std::string &rsIndexName) const

glo::IndexPool::_isObjIdFree
virtual int _isObjIdFree(const std::string &rsSchemaName, unsigned long ulClassID, const ObjID &rObjID) const

glo::IndexPool::~IndexPool
virtual ~IndexPool()

glo::IndexPool::releaseObjStrIdTuple
int releaseObjStrIdTuple(const std::string &rsSchemaName, unsigned long ulClassID, const std::string &rsIndexName, const NUM_PTR ipReservingComunicatorTrx)

glo::IndexPool::_removeFreeObjIDPos
virtual int _removeFreeObjIDPos(const std::string &rsSchemaName, unsigned long ulClassID, std::streampos Pos)

glo::ObjID
Ein Objekt-ID besteht aus der Klassen-ID, einer Datenbank-ID und der eigentlichen eindeutigen ObjektZ...
Definition GloObjID.h:77

glo::RealIndexPool
Der reale Index im Gegensatz zum TransactionIndexPool, welcher für jede Transaktion erstellt wird.
Definition GloIndexPool.h:5151

glo::RealIndexPool::_readObjStrIndexes
int _readObjStrIndexes(const SchemaInterface &rSchemaInterface)

glo::RealIndexPool::_reindexObjIDIndexes
int _reindexObjIDIndexes(const SchemaInterface &rSchemaInterface)

glo::RealIndexPool::_writeObjStrIndexes
int _writeObjStrIndexes(const SchemaInterface &rSchemaInterface) const

glo::RealIndexPool::writeIndexes
int writeIndexes(const SchemaInterface &rSchemaInterface, int iActions)

glo::RealIndexPool::~RealIndexPool
virtual ~RealIndexPool()

glo::RealIndexPool::writeObjIDIndexes
int writeObjIDIndexes(const SchemaInterface &rSchemaInterface) const

glo::RealIndexPool::getNumberOfClassInfos
std::size_t getNumberOfClassInfos(const SchemaInterface &rSchemaInterface) const

glo::RealIndexPool::_reindexObjStrIndexes
int _reindexObjStrIndexes(const SchemaInterface &rSchemaInterface)

glo::RealIndexPool::reindexObjIDIndexes
int reindexObjIDIndexes(const SchemaInterface &rSchemaInterface)

glo::RealIndexPool::writeObjStrIndexes
int writeObjStrIndexes(const SchemaInterface &rSchemaInterface) const

glo::RealIndexPool::readIndexes
int readIndexes(const SchemaInterface &rSchemaInterface)

glo::RealIndexPool::existsSchemaIndex
virtual bool existsSchemaIndex(const std::string &rsSchemaName) const

glo::RealIndexPool::RealIndexPool
RealIndexPool(const RealIndexPool &rT)

glo::RealIndexPool::setWatchNotifyManager
void setWatchNotifyManager(WatchNotifyManager *pWatchNotifyManager)

glo::RealIndexPool::m_iActions
int m_iActions
Definition GloIndexPool.h:5179

glo::RealIndexPool::reindexObjStrIndexes
int reindexObjStrIndexes(const SchemaInterface &rSchemaInterface)

glo::RealIndexPool::removeSchemaIndex
int removeSchemaIndex(const std::string &rsSchemaName)

glo::RealIndexPool::getNumberOfIndexes
std::size_t getNumberOfIndexes(const SchemaInterface &rSchemaInterface) const

glo::RealIndexPool::reindex
int reindex(const SchemaInterface &rSchemaInterface)

glo::RealIndexPool::insertFreeObjIDPos
virtual int insertFreeObjIDPos(const std::string &rsSchemaName, unsigned long ulClassID, std::streampos Pos)

glo::RealIndexPool::_getIndexString
int _getIndexString(std::string &rsRetValIndex, const std::vector< eut::LanguageFunctions::EnLanguageKey > &rLanguageKeys, bool bCaseSensitive, const SchemaInterface &rSchemaInterface, unsigned long ulClassID, const ObjID &rObjID, const ClassInfoIndex::IndexAttributeItem &rIndexAttributeItem)

glo::RealIndexPool::RealIndexPool
RealIndexPool()

glo::RealIndexPool::notifyIndexReadWrite
void notifyIndexReadWrite(TdWatchNotifyMode iMode, const std::string &rsSchemaName, const ObjID &rObjID, int iFraction, int iActions)

glo::RealIndexPool::getFreeObjIDPos
virtual int getFreeObjIDPos(std::streampos &rPos, const std::string &rsSchemaName, unsigned long ulClassID) const

glo::RealIndexPool::_writeObjIDIndexes
int _writeObjIDIndexes(const SchemaInterface &rSchemaInterface) const

glo::RealIndexPool::m_pWatchNotifyManager
WatchNotifyManager * m_pWatchNotifyManager
Definition GloIndexPool.h:5166

glo::RealIndexPool::writeIndexes
int writeIndexes(const SchemaInterface &rSchemaInterface)

glo::RealIndexPool::removeFreeObjIDPos
virtual int removeFreeObjIDPos(const std::string &rsSchemaName, unsigned long ulClassID, std::streampos Pos)

glo::RealIndexPool::_readObjIDIndexes
int _readObjIDIndexes(const SchemaInterface &rSchemaInterface)

glo::RealIndexPool::_writeObjStrIndexes
int _writeObjStrIndexes(const SchemaIndex &rSchemaIndex) const

glo::RealIndexPool::reindex
int reindex(const SchemaInterface &rSchemaInterface, int iActions)

glo::RealIndexPool::_writeObjIDIndexes
int _writeObjIDIndexes(const SchemaIndex &rSchemaIndex) const

glo::RealIndexPool::_createObjIDIndexFromTable
int _createObjIDIndexFromTable(const SchemaInterface &rSchemaInterface, const ClassInfoAttribute &rClassInfoAttribute)

glo::RealIndexPool::_createObjStrIndexFromTables
int _createObjStrIndexFromTables(const SchemaInterface &rSchemaInterface, const ClassInfoIndex &rClassInfoIndex)

glo::SchemaInterface
Diese Klasse ist die Schnittstelle zu einem GlobalObjects-Schema. Sie beinhaltet alle Klasseninformat...
Definition GloSchemaInterface.h:84

glo::TransactionIndexPool
Dieser Index wird in jeder Transaktion generiert und die Änderungen wie speichern,...
Definition GloIndexPool.h:5924

glo::TransactionIndexPool::insertTransactionDeletedObjID
int insertTransactionDeletedObjID(const std::string &rsSchemaName, const ObjID &rDeletedObjId)

glo::TransactionIndexPool::operator=
TransactionIndexPool & operator=(const TransactionIndexPool &rT)
Zuweisungsoperator.

glo::TransactionIndexPool::removeTransactionDeletedObjID
int removeTransactionDeletedObjID(const std::string &rsSchemaName, const ObjID &rDeletedObjId)

glo::TransactionIndexPool::TransactionIndexPool
TransactionIndexPool(const TransactionIndexPool &rT)
Copy-Konstruktor.

glo::TransactionIndexPool::TransactionIndexPool
TransactionIndexPool(const IndexPool &rT)
Copy-Konstruktor.

glo::TransactionIndexPool::~TransactionIndexPool
virtual ~TransactionIndexPool()

glo::TransactionIndexPool::TransactionIndexPool
TransactionIndexPool()

glo::WatchNotifyManager
Klassen um persistente Objekte überwachen zu können und bei Änderungen die jeweiligen Clients zu bean...
Definition GloWatchNotifyManager.h:344

glo
Definition GloAbstractBaseLot.h:42

glo::EnComparisionOp
EnComparisionOp
Definition GloTypes.h:1583

glo::EQUAL
@ EQUAL
Definition GloTypes.h:1593

glo::EnSeekMode
EnSeekMode
Definition GloTypes.h:166

glo::EnQueryType
EnQueryType
Definition GloTypes.h:1179

glo::TdWatchNotifyMode
unsigned long TdWatchNotifyMode
Definition GloTypes.h:543

glo::IndexPool::IndexComparisionFilter
Filter können Objekten vom Typ ObjectStrIndexIterator zugeordnet werden, welche das Iterieren durch e...
Definition GloIndexPool.h:2376

glo::IndexPool::IndexComparisionFilter::~IndexComparisionFilter
virtual ~IndexComparisionFilter()
Definition GloIndexPool.h:2411

glo::IndexPool::IndexComparisionFilter::m_eComparisionOperator
EnComparisionOp m_eComparisionOperator
Definition GloIndexPool.h:2387

glo::IndexPool::IndexComparisionFilter::IndexComparisionFilter
IndexComparisionFilter()
Definition GloIndexPool.h:2398

glo::IndexPool::IndexFilter
Filter können Objekten vom Typ ObjectStrIndexIterator zugeordnet werden, welche das Iterieren durch e...
Definition GloIndexPool.h:2319

glo::IndexPool::IndexFilter::~IndexFilter
virtual ~IndexFilter()
Definition GloIndexPool.h:2343

glo::IndexPool::IndexFilter::m_sIndexFilterValue
std::string m_sIndexFilterValue
Definition GloIndexPool.h:2332

glo::IndexPool::IndexRangeFilter
Filter können Objekten vom Typ ObjectStrIndexIterator zugeordnet werden, welche das Iterieren durch e...
Definition GloIndexPool.h:2448

glo::IndexPool::IndexRangeFilter::m_sIndexFilterEndValue
std::string m_sIndexFilterEndValue
Definition GloIndexPool.h:2459

glo::IndexPool::IndexRangeFilter::~IndexRangeFilter
virtual ~IndexRangeFilter()
Definition GloIndexPool.h:2470