d7/d58/_glo_manager_8h_source.html

#ifndef INC_GLODBMANAGER_H

#define INC_GLODBMANAGER_H

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

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

#include "GloTypes.h"

#include "GloOrderMsg.h"

#include <string>

#if defined (__PTHREADS)

  #include <EuPCriticalSection.h>

#else

  #include "EuCriticalSection.h"

#endif

#include "PtlTDVList.h"

#include "GloTransactionManager.h"

#include "GloTransactionOwner.h"

#include "GloLockSpecification.h"

#include "GloWatchSpecification.h"

#include "GloTransactionOwner.h"

#if defined (__PTHREADS)

  #include <EuEndlessPThread.h>

  #include <semaphore.h>

#else

  #include "EuRepeatingThread.h"

#endif

#include <vector>

#include <map>

#include <queue>

#include <fstream>

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

  #include <winsock.h>

#elif defined(__GNUC__)

  #include <string.h>


  #include <errno.h>

  #include <sys/types.h>

  #include <sys/socket.h>

  #include <netinet/in.h>

  #include <netdb.h>

  #include <arpa/inet.h>

  #define SOCKET uintptr_t

  #define SOCKADDR_IN sockaddr_in

  #define SOCKADDR sockaddr

  #define HOSTENT hostent

  #define INVALID_SOCKET  (SOCKET)(~0)

  #define SOCKET_ERROR            (-1)

#endif

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

namespace glo

{

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

  /* Forwards */

  class CommunicaterThread;

  class Communicator;

  class LockManager;

  class ManagerActionVisualiser;

  class ObjID;

  class RealIndexPool;

  class Record;

  class SchemaInterface;

  class Server;

  class TableReaderInterface;

  class TransactionIndexPool;

  class TableWriterInterface;

  class WatchNotifyManager;

  struct ClientInfo;

  class IndexPool;

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

  #ifdef _MSC_VER

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

    #pragma warning( disable : 4251 )

  #endif

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

  #if defined (__PTHREADS)

    class __glo_export_dll Manager : public EuEndlessPThread

  #else


    class __glo_export_dll Manager : public eut::RepeatingThread

  #endif

  {

    private:

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

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

      friend class WatchNotifyManager;

      friend class LockManager;

      friend class OrderMsg;

      friend class TcpServerReceiver;

      friend class TableWriterInterface;

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


    protected:

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

      // >>>>>>>>>>>>>>>>>>>>>>>> Receiver >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

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


      class Receiver

      {

        private:

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

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

          unsigned int m_uiRefCounter;

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

          std::string m_sSchemaName;

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

          Communicator * m_pCommunicator;

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

          CommunicaterThread * m_pCommunicatorThread;

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


          //============= Konstruktor

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

          Receiver();

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

          Receiver( const Receiver & );

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


        public:

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

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

          Receiver( const std::string & sSchemaName,

                    CommunicaterThread * pCommunicatorThread,

                    Communicator * pCommunicator );

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

          ~Receiver();

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


        public:

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

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

          std::string getSchemaName() const;

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

          Communicator * getCommunicator() const;

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

          CommunicaterThread * getCommunicatorThread() const;

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

          unsigned int incrementRefCounter();

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

          unsigned int decrementRefCounter();

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


        private:

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

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

          Manager::Receiver & operator= ( const Receiver & );

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

      };


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

      // <<<<<<<<<<<<<<<<<<<<<<<< Receiver <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

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


    protected:

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

      // >>>>>>>>>>>>>>>>>>>>> ObjIdWithDepends >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

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

      // doxygen -> warning: unable to resolve reference to 'GLO_REF_DEPENDENT' for \ref command

      // Is a reference to the GlobalObjects documentation.

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


      struct ObjIdWithDepends

      {

        public:

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

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

          ObjID m_ObjID;

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

          // doxygen -> warning: unable to resolve reference to 'GLO_REF_DEPENDENT' for \ref command

          // Is a reference to the GlobalObjects documentation.

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

          std::map< ObjID, Record *, std::less<ObjID> > * m_pDependRecordMap;

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


          //============== Konstruktoren

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

          // doxygen -> warning: unable to resolve reference to 'GLO_REF_DEPENDENT' for \ref command

          // Is a reference to the GlobalObjects documentation.

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

          ObjIdWithDepends( const ObjID & rObjID,

                            std::map< ObjID, Record *, std::less<ObjID> > * pDependRecordMap );

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

          ~ObjIdWithDepends();

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

      };


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

      // <<<<<<<<<<<<<<<<<<<<< ObjIdWithDepends <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

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


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

      // >>>>>>>>>>>>>>>>>>>>>> SchemaMapItem >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

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


      class SchemaMapItem

      {

        private:

          //+ ============ Attribute

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

          unsigned int m_uiCounter;

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

          SchemaInterface * m_pSchema;

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

          TableWriterInterface * m_pTableWriterInterface;

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

          #if defined(_MSC_VER)

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

            std::ofstream * m_pLockFile;

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

          #elif defined(__MINGW32__) || defined(__MINGW64__)

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

            void * m_hLockFileHandle;

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

          #elif defined(__GNUC__)

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

            int m_iLockFileHandle;

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

          #endif

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


        protected:

          //============= Konstruktor

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

          SchemaMapItem();

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


        public:

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

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

          #if defined(_MSC_VER)

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

            SchemaMapItem(  SchemaInterface * pSchema,

                            RealIndexPool * pRealIndexPool,

                            std::ofstream * pLockFile );

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

          #elif defined(__MINGW32__) || defined(__MINGW64__)

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

            SchemaMapItem(  SchemaInterface * pSchema,

                            RealIndexPool * pRealIndexPool,

                            void * hLockFileHandle );

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

          #elif defined(__GNUC__)

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

            SchemaMapItem(  SchemaInterface * pSchema,

                            RealIndexPool * pRealIndexPool,

                            int iLockFileHandle );

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

          #endif

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

          #if defined(_MSC_VER)

          #elif defined(__MINGW32__) || defined(__MINGW64__)

          #elif defined(__GNUC__)

          #endif

          ~SchemaMapItem();

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


        private:

          //============== Konstruktoren

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

          SchemaMapItem( const SchemaMapItem & );

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


        public:

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

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

          void incrementCounter();

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

          void decrementCounter();

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

          unsigned int Counter() const;

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

          SchemaInterface * getSchema() const;

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

          TableWriterInterface * getTableWriterInterface() const;

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


        private:

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

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

          Manager::SchemaMapItem & operator= ( const SchemaMapItem & );

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

      };


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

      // <<<<<<<<<<<<<<<<<<<<<<< SchemaMapItem <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

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


    private:

      //============== Static-Attribute

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

      static int ms_iReferenceCounter;

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

      static Manager * m_pInstance;

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

      static ShowLevel m_ulShowLevel;

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

      static ManagerActionVisualiser * m_pActionVisualiser;


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

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

      unsigned int m_uiCommunicatorID;

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

      std::string m_strSchemaPath;

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

      std::vector<std::string> m_KnownSchemes;

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

      std::map< std::string, SchemaMapItem *, std::less< std::string > > m_SchemaMap;

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

      std::queue< OrderMsg * > m_MsgQueue;

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

      std::map< SOCKET, ClientInfo , std::less< SOCKET > > m_ConnectedClientsMap;

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

      std::map< Communicator *, Receiver * , std::less< Communicator * > > m_ReceiverMap;

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

      LockManager * m_pLockManager;

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

      TransactionManager * m_pTransactionManager;

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

      WatchNotifyManager * m_pWatchNotifyManager;

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

      RealIndexPool * m_pRealIndexPool;

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

      bool m_bWorkingExclusiv;

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

      #if defined (__PTHREADS)

        EuPCriticalSection m_LocalCriticalSection;

      #else

        eut::CriticalSection m_LocalCriticalSection;

      #endif

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


    protected:

      //============= Konstruktoren

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

      Manager()

      #if defined(__GNUC__)

        __attribute__((noreturn))

      #endif

      ;

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

      Manager(  const std::string & rsSchemaPath,

                const std::vector< std::string > & rAllowedSchemes );

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

      virtual ~Manager();

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


    private:

      //============== Konstruktoren

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

      Manager( const Manager & );

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


    public:

      //============== statische Methoden

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

      static Manager * create(  const std::string & rsSchemaPath,

                                const std::vector< std::string > & rAllowedSchemes );

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

      static int destroy();

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

      static Manager * getAvailableInstance();

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

      static void setActionVisualiser( ManagerActionVisualiser * pActionVisualiser );

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

      static void setShowLevel( ShowLevel ulLevel );

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

      static ShowLevel getShowLevel ();

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

      static void showActionString( const std::string & sActionString );

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

      static void showAction( const OrderMsg * pOrderMsg,

                              const std::string & rsActiontype,

                              const std::string & rsActionString,

                              char cSE);

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

      static void showOrderAction( OrderMsg * pOrderMsg, char cSE );

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

      static void showTransactionAction(  OrderMsg * pOrderMsg,

                                          const std::string & rsActionString,

                                          char cSE);

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

      static void showWriterAction( OrderMsg * pOrderMsg,

                                    const std::string & rsActionString,

                                    char cSE);

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

      static void showReaderAction( OrderMsg * pOrderMsg,

                                    const std::string & rsActionString,

                                    char cSE);

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


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

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

      RealIndexPool * getRealIndexPool();

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

      std::string getSchemaPath() const;

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

      void getKnownBases( std::vector< std::string > & rKnownBasesVector ) const;

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

      bool isBaseOpen( Communicator * pCommunicator );

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

      int takeOrder( OrderMsg * pOrderMsg );

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

      void getAllClients( std::vector< ClientInfo > & rClientInfoVector,

                          std::string * psSchemaName = 0 ) const;

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


    #ifdef _GLO_TEST

      public:

    #else

      protected:

    #endif

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

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

      Manager::SchemaMapItem * getSchemaMapItem( const std::string & rsSchemaName ) const;

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

      SchemaInterface * getSchemaInterface( const std::string & rsSchemaName ) const;

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

      int createSchemaInterface( SchemaInterface *& prNewSchemaInterface,

                                 const std::string & rsSchemaName ) const;

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

      void insertInKnownBases( const std::vector< std::string > & rNewSchemes );

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


      //============== Auftrags-Methoden

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

      void getAllKnownBases( OrderMsg * pOrderMsg ) const;

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

      void getClassInfo( OrderMsg * pOrderMsg ) const;

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

      void getBaseOrSubClassInfos( OrderMsg * pOrderMsg ) const;

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

      void getAllDataTypes( OrderMsg * pOrderMsg ) const;

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

      void getDataTypeLimits( OrderMsg * pOrderMsg ) const;

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

      void getAllClients( OrderMsg * pOrderMsg ) const;

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

      void openBase( OrderMsg * pOrderMsg );

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

      void closeBase( OrderMsg * pOrderMsg );

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

      void reindexBase( OrderMsg * pOrderMsg );

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

      void compressBase( OrderMsg * pOrderMsg );

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

      void repairBase( OrderMsg * pOrderMsg );

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

      void removeCommunicator( OrderMsg * pOrderMsg,

                               WatchNotifyManager * pWatchNotifyManager = 0 );

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

      void processNewConnectedClient( OrderMsg * pOrderMsg );

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

      void processDisconnectedClient( OrderMsg * pOrderMsg );

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

      void sendToReaderThread( OrderMsg * pOrderMsg );

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

      void sendToWriter( OrderMsg * pOrderMsg );

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

      int sendBEGINtoTransactionManager( const TransactionOwner & rCommunicatorWithTreadID );

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

      int sendABORTtoTransactionManager(  const TransactionOwner & rCommunicatorWithTreadID,

                                          std::string sSchemaName );

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

      int sendCOMMITtoTransactionManager( const TransactionOwner & rCommunicatorWithTreadID,

                                          std::string sSchemaName,

                                          std::map< ObjID, Record *, std::less<ObjID> > * pInputDataRecordMap );

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

      void sendToTransactionManager( OrderMsg * pOrderMsg );

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

      #ifdef _GLO_TEST

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

      LockManager * getLockManager();

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

      #endif

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

      void sendToLockManager( OrderMsg * pOrderMsg );

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

      int sendToLockManager(  OrderMsg::EnOrderType eOrderType,

                              SchemaInterface * pSchema,

                              std::list<ObjID> * pObjectIDsToBeLocked,

                              LockSpecification * pLockSpec,

                              const TransactionOwner & rCommunicatorWithTreadID );

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

      void sendToWatchNotifyManager( OrderMsg * pOrderMsg );

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

      void deleteCommunicatorWatches( OrderMsg * pOrderMsg );

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

      void processObjectNotify( TdWatchNotifyMode nWatchNotifyMode,

                                const ObjID & rObjID,

                                Communicator * pCommunicator,

                                const std::string & rsSchemaName );

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

      void processObjectNotify( TdWatchNotifyMode nWatchNotifyMode,

                                const std::list<ObjID> & rObjIDList,

                                Communicator * pCommunicator,

                                const std::string & rsSchemaName );

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


      //============== Unterstützer-Methoden

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

      #if defined(_MSC_VER)

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

      int lockBaseExclusive( std::ofstream *& prLockFile,

                             const SchemaInterface & rSchemaInterface );

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

      #elif defined(__MINGW32__) || defined(__MINGW64__)

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

      int lockBaseExclusive( void *& prLockFileHandle,

                             const SchemaInterface & rSchemaInterface );

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

      #elif defined(__GNUC__)

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

      int lockBaseExclusive( int & riLockFileHandle,

                             const SchemaInterface & rSchemaInterface );

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

      #endif

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

      Manager::Receiver * getReceiver( Communicator * pCommunicator );

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

      std::size_t getNumberReceiver() const;

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

      std::size_t getNumberReceiver( std::string sSchemaName ) const;

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

      void switchOffAllRecieverReader();

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

      void switchOffRecieverReader( std::string sSchemaName );

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

      void switchOnAllRecieverReader();

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

      void switchOnRecieverReader( std::string sSchemaName );

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

      void getAllTransactionIndexPools( std::vector< TransactionIndexPool * > & rTransactionIndexPoolVector,

                                        std::string * psSchemaName = 0,

                                        Communicator * pWithoutThisCommunicator = 0 ) const;

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

      int transactionManagerSetTransactionStep( const SchemaInterface & rSchema,

                                                const TransactionOwner & rCommunicatorWithTreadID,

                                                TransactionManager::EnStoreDelete eStoreOrDelete,

                                                Record * pRecord );

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

      int checkAllRecordIndices(  int iCheckStatus,

                                  const SchemaInterface & rSchema,

                                  const std::map< ObjID, Record *, std::less<ObjID> > & rRecordMap,

                                  IndexPool & rGloIndexPool ) const;

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

      void releaseStrIndexesFromTransactionStepList( std::list< TransactionManager::TransactionBase * > & rTransactionStepList,

                                                     std::string & rsSchemaName );

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

      void unlockTransactionStepList( std::list< TransactionManager::TransactionBase * > & rTransactionStepList,

                                      const TransactionOwner & rCommunicatorWithTreadID,

                                      const std::string & rsSchemaName,

                                      TransactionIndexPool * pTransactionIndexPool,

                                      bool bDelete );

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

      // doxygen -> warning: unable to resolve reference to 'GLO_REF_DEPENDENT' for \ref command

      // Is a reference to the GlobalObjects documentation.

      int getRecord(  Record *& prRetVal,

                      const glo::ObjID & rObjID,

                      const TableReaderInterface & rTableReaderInterface,

                      TransactionOwner * pCommunicatorWithTreadID = nullptr ) const;

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

      // doxygen -> warning: unable to resolve reference to 'GLO_REF_DEPENDENT' for \ref command

      // Is a reference to the GlobalObjects documentation.

      void getDependRecords(  std::map< ObjID, Record *, std::less<ObjID> > & rDependRecordMap,

                              Record & rSourceRecord,

                              const TableReaderInterface & rTableReaderInterface,

                              EnDeepMode eDeepMode,

                              TransactionOwner * pCommunicatorWithTreadID = nullptr ) const;

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

      // doxygen -> warning: unable to resolve reference to 'GLO_REF_DEPENDENT' for \ref command

      // Is a reference to the GlobalObjects documentation.

      void getDependRecordsRecursive( std::map< ObjID, Record *, std::less<ObjID> > & rDependRecordMap,

                                      Record & rSourceRecord,

                                      const TableReaderInterface & rTableReaderInterface,

                                      EnDeepMode eDeepMode,

                                      TransactionOwner * pCommunicatorWithTreadID = nullptr ) const;

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

      void deleteAllObjectsInSchemaMap();

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

      void deleteAllObjectsInReceiverMap();

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


      //============== Die Thread-Methode

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

      virtual void work() override;

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


    private:

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

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

      Manager & operator= ( const Manager & );

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

  };


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

  #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

EuEndlessPThread.h
Header für EuEndlessPThread

EuPCriticalSection.h
Header für EuPCriticalSection

EuRepeatingThread.h
Header für RepeatingThread

GloLockSpecification.h
Header für LockSpecification

GloOrderMsg.h
Header für OrderMsg

GloTransactionManager.h
Header für TransactionManager    TransactionManager::TransactionBase   TransactionManager::Transactio...

GloTransactionOwner.h
Header für TransactionOwner

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

__glo_export_dll
#define __glo_export_dll
Definition GloTypes.h:70

GloWatchSpecification.h
Header für WatchSpecification

PtlTDVList.h
Header für TDVList

EuEndlessPThread
Basisklasse für einen Thread der seine Arbeit endlos bis zum Abbruch ausführt.
Definition EuEndlessPThread.h:84

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

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

eut::RepeatingThread
Basisklasse für einen Thread der seine Arbeit endlos bis zum Abbruch ausführt.
Definition EuRepeatingThread.h:93

glo::CommunicaterThread
Ein CommunicaterThread nimmt Aufträge für sein TableReaderInterface an.
Definition GloCommunicaterThread.h:89

glo::Communicator
OberKlasse von LocalThread, ClientThread und ServerThread, weil diese als Sender und Empfänger (Kommu...
Definition GloCommunicator.h:93

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

glo::LockManager
Objekte dieser Klasse überwachen den Sperrzustand von Objekten.
Definition GloLockManager.h:239

glo::LockSpecification
Um Objekte sperren zu können, werden der 'Lock-Modus' und die 'Sperrtiefe' als Parameter benötigt....
Definition GloLockSpecification.h:65

glo::Manager::Receiver
Ist die Gegenstelle bzw. der Kommunikator, welcher mit dem Manager kommuniziert. Bei dem Mehrbenutzbe...
Definition GloManager.h:225

glo::Manager::Receiver::~Receiver
~Receiver()

glo::Manager::Receiver::m_pCommunicatorThread
CommunicaterThread * m_pCommunicatorThread
Definition GloManager.h:281

glo::Manager::Receiver::getSchemaName
std::string getSchemaName() const

glo::Manager::Receiver::Receiver
Receiver()

glo::Manager::Receiver::m_sSchemaName
std::string m_sSchemaName
Definition GloManager.h:259

glo::Manager::Receiver::m_uiRefCounter
unsigned int m_uiRefCounter
Definition GloManager.h:246

glo::Manager::Receiver::decrementRefCounter
unsigned int decrementRefCounter()

glo::Manager::Receiver::Receiver
Receiver(const std::string &sSchemaName, CommunicaterThread *pCommunicatorThread, Communicator *pCommunicator)

glo::Manager::Receiver::Receiver
Receiver(const Receiver &)

glo::Manager::Receiver::m_pCommunicator
Communicator * m_pCommunicator
Definition GloManager.h:270

glo::Manager::Receiver::incrementRefCounter
unsigned int incrementRefCounter()

glo::Manager::Receiver::getCommunicatorThread
CommunicaterThread * getCommunicatorThread() const

glo::Manager::Receiver::getCommunicator
Communicator * getCommunicator() const

glo::Manager::SchemaMapItem
Objekte dieser Klasse repräsentieren eine geöffnete Datenbank. Es gibt für jede geöffnete Datenbank e...
Definition GloManager.h:569

glo::Manager::SchemaMapItem::m_pTableWriterInterface
TableWriterInterface * m_pTableWriterInterface
Definition GloManager.h:608

glo::Manager::SchemaMapItem::Counter
unsigned int Counter() const

glo::Manager::SchemaMapItem::SchemaMapItem
SchemaMapItem(const SchemaMapItem &)

glo::Manager::SchemaMapItem::SchemaMapItem
SchemaMapItem()

glo::Manager::SchemaMapItem::m_pSchema
SchemaInterface * m_pSchema
Definition GloManager.h:597

glo::Manager::SchemaMapItem::m_pLockFile
std::ofstream * m_pLockFile
Definition GloManager.h:624

glo::Manager::SchemaMapItem::incrementCounter
void incrementCounter()

glo::Manager::SchemaMapItem::m_uiCounter
unsigned int m_uiCounter
Definition GloManager.h:586

glo::Manager::SchemaMapItem::getTableWriterInterface
TableWriterInterface * getTableWriterInterface() const

glo::Manager::SchemaMapItem::~SchemaMapItem
~SchemaMapItem()

glo::Manager::SchemaMapItem::getSchema
SchemaInterface * getSchema() const

glo::Manager::SchemaMapItem::decrementCounter
void decrementCounter()

glo::Manager::SchemaMapItem::SchemaMapItem
SchemaMapItem(SchemaInterface *pSchema, RealIndexPool *pRealIndexPool, std::ofstream *pLockFile)

glo::ManagerActionVisualiser
Zeigt die Aktionen des Manager über std::cout an.
Definition GloManagerActionVisualiser.h:70

glo::Manager
Das Objekt dieser Klasse ist die zentrale Anlaufstelle für Aktionen, welche mit GlobalObjects-Daten z...
Definition GloManager.h:193

glo::Manager::transactionManagerSetTransactionStep
int transactionManagerSetTransactionStep(const SchemaInterface &rSchema, const TransactionOwner &rCommunicatorWithTreadID, TransactionManager::EnStoreDelete eStoreOrDelete, Record *pRecord)

glo::Manager::createSchemaInterface
int createSchemaInterface(SchemaInterface *&prNewSchemaInterface, const std::string &rsSchemaName) const

glo::Manager::getShowLevel
static ShowLevel getShowLevel()

glo::Manager::m_ConnectedClientsMap
std::map< SOCKET, ClientInfo, std::less< SOCKET > > m_ConnectedClientsMap
Definition GloManager.h:1050

glo::Manager::getRealIndexPool
RealIndexPool * getRealIndexPool()

glo::Manager::create
static Manager * create(const std::string &rsSchemaPath, const std::vector< std::string > &rAllowedSchemes)

glo::Manager::deleteCommunicatorWatches
void deleteCommunicatorWatches(OrderMsg *pOrderMsg)

glo::Manager::openBase
void openBase(OrderMsg *pOrderMsg)

glo::Manager::getDependRecordsRecursive
void getDependRecordsRecursive(std::map< ObjID, Record *, std::less< ObjID > > &rDependRecordMap, Record &rSourceRecord, const TableReaderInterface &rTableReaderInterface, EnDeepMode eDeepMode, TransactionOwner *pCommunicatorWithTreadID=nullptr) const

glo::Manager::sendToWatchNotifyManager
void sendToWatchNotifyManager(OrderMsg *pOrderMsg)

glo::Manager::getAllTransactionIndexPools
void getAllTransactionIndexPools(std::vector< TransactionIndexPool * > &rTransactionIndexPoolVector, std::string *psSchemaName=0, Communicator *pWithoutThisCommunicator=0) const

glo::Manager::compressBase
void compressBase(OrderMsg *pOrderMsg)

glo::Manager::getNumberReceiver
std::size_t getNumberReceiver() const

glo::Manager::showWriterAction
static void showWriterAction(OrderMsg *pOrderMsg, const std::string &rsActionString, char cSE)

glo::Manager::Manager
Manager()

glo::Manager::~Manager
virtual ~Manager()

glo::Manager::m_KnownSchemes
std::vector< std::string > m_KnownSchemes
Definition GloManager.h:1015

glo::Manager::getAllDataTypes
void getAllDataTypes(OrderMsg *pOrderMsg) const

glo::Manager::m_pWatchNotifyManager
WatchNotifyManager * m_pWatchNotifyManager
Definition GloManager.h:1096

glo::Manager::getSchemaMapItem
Manager::SchemaMapItem * getSchemaMapItem(const std::string &rsSchemaName) const

glo::Manager::m_pActionVisualiser
static ManagerActionVisualiser * m_pActionVisualiser
Definition GloManager.h:980

glo::Manager::getRecord
int getRecord(Record *&prRetVal, const glo::ObjID &rObjID, const TableReaderInterface &rTableReaderInterface, TransactionOwner *pCommunicatorWithTreadID=nullptr) const

glo::Manager::deleteAllObjectsInReceiverMap
void deleteAllObjectsInReceiverMap()

glo::Manager::m_ReceiverMap
std::map< Communicator *, Receiver *, std::less< Communicator * > > m_ReceiverMap
Definition GloManager.h:1063

glo::Manager::getSchemaPath
std::string getSchemaPath() const

glo::Manager::m_LocalCriticalSection
eut::CriticalSection m_LocalCriticalSection
Definition GloManager.h:1137

glo::Manager::processObjectNotify
void processObjectNotify(TdWatchNotifyMode nWatchNotifyMode, const std::list< ObjID > &rObjIDList, Communicator *pCommunicator, const std::string &rsSchemaName)

glo::Manager::checkAllRecordIndices
int checkAllRecordIndices(int iCheckStatus, const SchemaInterface &rSchema, const std::map< ObjID, Record *, std::less< ObjID > > &rRecordMap, IndexPool &rGloIndexPool) const

glo::Manager::ms_iReferenceCounter
static int ms_iReferenceCounter
Definition GloManager.h:947

glo::Manager::insertInKnownBases
void insertInKnownBases(const std::vector< std::string > &rNewSchemes)

glo::Manager::m_strSchemaPath
std::string m_strSchemaPath
Definition GloManager.h:1004

glo::Manager::deleteAllObjectsInSchemaMap
void deleteAllObjectsInSchemaMap()

glo::Manager::lockBaseExclusive
int lockBaseExclusive(std::ofstream *&prLockFile, const SchemaInterface &rSchemaInterface)

glo::Manager::processObjectNotify
void processObjectNotify(TdWatchNotifyMode nWatchNotifyMode, const ObjID &rObjID, Communicator *pCommunicator, const std::string &rsSchemaName)

glo::Manager::getDataTypeLimits
void getDataTypeLimits(OrderMsg *pOrderMsg) const

glo::Manager::m_pLockManager
LockManager * m_pLockManager
Definition GloManager.h:1074

glo::Manager::m_ulShowLevel
static ShowLevel m_ulShowLevel
Definition GloManager.h:969

glo::Manager::showTransactionAction
static void showTransactionAction(OrderMsg *pOrderMsg, const std::string &rsActionString, char cSE)

glo::Manager::releaseStrIndexesFromTransactionStepList
void releaseStrIndexesFromTransactionStepList(std::list< TransactionManager::TransactionBase * > &rTransactionStepList, std::string &rsSchemaName)

glo::Manager::getBaseOrSubClassInfos
void getBaseOrSubClassInfos(OrderMsg *pOrderMsg) const

glo::Manager::repairBase
void repairBase(OrderMsg *pOrderMsg)

glo::Manager::switchOffAllRecieverReader
void switchOffAllRecieverReader()

glo::Manager::getDependRecords
void getDependRecords(std::map< ObjID, Record *, std::less< ObjID > > &rDependRecordMap, Record &rSourceRecord, const TableReaderInterface &rTableReaderInterface, EnDeepMode eDeepMode, TransactionOwner *pCommunicatorWithTreadID=nullptr) const

glo::Manager::sendToTransactionManager
void sendToTransactionManager(OrderMsg *pOrderMsg)

glo::Manager::setActionVisualiser
static void setActionVisualiser(ManagerActionVisualiser *pActionVisualiser)

glo::Manager::getAllKnownBases
void getAllKnownBases(OrderMsg *pOrderMsg) const

glo::Manager::Manager
Manager(const Manager &)

glo::Manager::sendToLockManager
int sendToLockManager(OrderMsg::EnOrderType eOrderType, SchemaInterface *pSchema, std::list< ObjID > *pObjectIDsToBeLocked, LockSpecification *pLockSpec, const TransactionOwner &rCommunicatorWithTreadID)

glo::Manager::getClassInfo
void getClassInfo(OrderMsg *pOrderMsg) const

glo::Manager::sendCOMMITtoTransactionManager
int sendCOMMITtoTransactionManager(const TransactionOwner &rCommunicatorWithTreadID, std::string sSchemaName, std::map< ObjID, Record *, std::less< ObjID > > *pInputDataRecordMap)

glo::Manager::removeCommunicator
void removeCommunicator(OrderMsg *pOrderMsg, WatchNotifyManager *pWatchNotifyManager=0)

glo::Manager::sendBEGINtoTransactionManager
int sendBEGINtoTransactionManager(const TransactionOwner &rCommunicatorWithTreadID)

glo::Manager::sendToLockManager
void sendToLockManager(OrderMsg *pOrderMsg)

glo::Manager::showOrderAction
static void showOrderAction(OrderMsg *pOrderMsg, char cSE)

glo::Manager::work
virtual void work() override

glo::Manager::closeBase
void closeBase(OrderMsg *pOrderMsg)

glo::Manager::getKnownBases
void getKnownBases(std::vector< std::string > &rKnownBasesVector) const

glo::Manager::m_SchemaMap
std::map< std::string, SchemaMapItem *, std::less< std::string > > m_SchemaMap
Definition GloManager.h:1028

glo::Manager::getAvailableInstance
static Manager * getAvailableInstance()

glo::Manager::sendABORTtoTransactionManager
int sendABORTtoTransactionManager(const TransactionOwner &rCommunicatorWithTreadID, std::string sSchemaName)

glo::Manager::getAllClients
void getAllClients(std::vector< ClientInfo > &rClientInfoVector, std::string *psSchemaName=0) const

glo::Manager::showActionString
static void showActionString(const std::string &sActionString)

glo::Manager::getAllClients
void getAllClients(OrderMsg *pOrderMsg) const

glo::Manager::unlockTransactionStepList
void unlockTransactionStepList(std::list< TransactionManager::TransactionBase * > &rTransactionStepList, const TransactionOwner &rCommunicatorWithTreadID, const std::string &rsSchemaName, TransactionIndexPool *pTransactionIndexPool, bool bDelete)

glo::Manager::destroy
static int destroy()

glo::Manager::switchOnRecieverReader
void switchOnRecieverReader(std::string sSchemaName)

glo::Manager::getSchemaInterface
SchemaInterface * getSchemaInterface(const std::string &rsSchemaName) const

glo::Manager::getNumberReceiver
std::size_t getNumberReceiver(std::string sSchemaName) const

glo::Manager::m_bWorkingExclusiv
bool m_bWorkingExclusiv
Definition GloManager.h:1120

glo::Manager::showReaderAction
static void showReaderAction(OrderMsg *pOrderMsg, const std::string &rsActionString, char cSE)

glo::Manager::m_MsgQueue
std::queue< OrderMsg * > m_MsgQueue
Definition GloManager.h:1039

glo::Manager::reindexBase
void reindexBase(OrderMsg *pOrderMsg)

glo::Manager::sendToWriter
void sendToWriter(OrderMsg *pOrderMsg)

glo::Manager::m_uiCommunicatorID
unsigned int m_uiCommunicatorID
Definition GloManager.h:993

glo::Manager::setShowLevel
static void setShowLevel(ShowLevel ulLevel)

glo::Manager::Manager
Manager(const std::string &rsSchemaPath, const std::vector< std::string > &rAllowedSchemes)

glo::Manager::m_pRealIndexPool
RealIndexPool * m_pRealIndexPool
Definition GloManager.h:1107

glo::Manager::showAction
static void showAction(const OrderMsg *pOrderMsg, const std::string &rsActiontype, const std::string &rsActionString, char cSE)

glo::Manager::processNewConnectedClient
void processNewConnectedClient(OrderMsg *pOrderMsg)

glo::Manager::switchOnAllRecieverReader
void switchOnAllRecieverReader()

glo::Manager::takeOrder
int takeOrder(OrderMsg *pOrderMsg)

glo::Manager::sendToReaderThread
void sendToReaderThread(OrderMsg *pOrderMsg)

glo::Manager::processDisconnectedClient
void processDisconnectedClient(OrderMsg *pOrderMsg)

glo::Manager::m_pInstance
static Manager * m_pInstance
Definition GloManager.h:958

glo::Manager::isBaseOpen
bool isBaseOpen(Communicator *pCommunicator)

glo::Manager::switchOffRecieverReader
void switchOffRecieverReader(std::string sSchemaName)

glo::Manager::getReceiver
Manager::Receiver * getReceiver(Communicator *pCommunicator)

glo::Manager::m_pTransactionManager
TransactionManager * m_pTransactionManager
Definition GloManager.h:1085

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

glo::OrderMsg
Mittels dieser Klasse wird die Kommunikation zwischen der Applikation, welche GlobalObjects nutzt und...
Definition GloOrderMsg.h:84

glo::OrderMsg::EnOrderType
EnOrderType
Definition GloOrderMsg.h:105

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

glo::Record
Objekte dieser Klasse transportieren die Daten von den Tabellen ins persistente Objekt und von diesen...
Definition GloRecord.h:108

glo::SchemaInterface
Diese Klasse ist die Schnittstelle zu einem GlobalObjects-Schema. Sie beinhaltet alle Klasseninformat...
Definition GloSchemaInterface.h:91

glo::TableReaderInterface
Ein Objekt dieser Klasse greift auf Tabellen zu und liest Datensätze (Record) und Binärdateien (eut::...
Definition GloTableReaderInterface.h:87

glo::TableWriterInterface
Ein Objekt dieser Klasse greift auf Tabellen zu und schreibt Datensätze (Record) und Binärdateien (eu...
Definition GloTableWriterInterface.h:77

glo::TcpServerReceiver
Klasse, welche über ein SOCKET mit einem tcp::Client kommunizieret und das Empfangsergebnis vom Typ M...
Definition GloTcpServerReceiver.h:81

glo::TransactionIndexPool
Dieser Index wird in jeder Transaktion generiert und die Änderungen wie speichern,...
Definition GloTransactionIndexPool.h:66

glo::TransactionManager
Klasse um Transaktionen zu gewährleisten.
Definition GloTransactionManager.h:172

glo::TransactionManager::EnStoreDelete
EnStoreDelete
Definition GloTransactionManager.h:186

glo::TransactionOwner
Um Transaktionen nicht nur einem glo::Communicator zur Verfügung zu stellen, sondern auch einzelnen T...
Definition GloTransactionOwner.h:81

glo::WatchNotifyManager
Klassen um persistente Objekte überwachen zu können und bei Änderungen die jeweiligen Clients zu bean...
Definition GloWatchNotifyManager.h:352

glo
Definition GloAbstractBaseLot.h:49

glo::EnDeepMode
EnDeepMode
Definition GloTypes.h:254

glo::ShowLevel
unsigned long ShowLevel
Definition GloTypes.h:839

glo::TdWatchNotifyMode
unsigned long TdWatchNotifyMode
Definition GloTypes.h:558

glo::Manager::ObjIdWithDepends
Eine Struktur um die Objekt-ID eines persistenten Objekts mit den Datensätzen der abhängigen Objekte ...
Definition GloManager.h:469

glo::Manager::ObjIdWithDepends::ObjIdWithDepends
ObjIdWithDepends(const ObjID &rObjID, std::map< ObjID, Record *, std::less< ObjID > > *pDependRecordMap)

glo::Manager::ObjIdWithDepends::m_pDependRecordMap
std::map< ObjID, Record *, std::less< ObjID > > * m_pDependRecordMap
Definition GloManager.h:498

glo::Manager::ObjIdWithDepends::m_ObjID
ObjID m_ObjID
Definition GloManager.h:482

glo::Manager::ObjIdWithDepends::~ObjIdWithDepends
~ObjIdWithDepends()

winsock.h