GloLockManager.h

Go to the documentation of this file.

#ifndef INC_GLOLOCKMANAGER_H
#define INC_GLOLOCKMANAGER_H
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// TrxByThread
//-----------------------------------------------------------------------------
#include <list>
#include <map>
#include <unordered_map>
#include <stack>
#include "GloTypes.h"
#include "GloManager.h"
#include "GloObjID.h"
#include "GloTransactionOwner.h"
//-----------------------------------------------------------------------------
namespace glo
{
  //---------------------------------------------------------------------------
  /* Forwards */
  class Communicator;
  class Manager;
  class Record;
  //---------------------------------------------------------------------------
  // doxygen -> warning: unable to resolve reference to 'GLO_REF_DEPENDENT' for \ref command
  // Is a reference to the GlobalObjects documentation.
  //---------------------------------------------------------------------------
  // English
  // |==========================================================================|
  // |            Obj1          |                      Obj2                     |
  // |--------------------------------------------------------------------------|
  // |LOCK |Guarantee|Protection|  Allowed LOCKs | Possibilities|  Restrictions |
  // |==========================================================================|
  // | NN  | none    | none     | all            | all          | none          |
  // | RD  | R       | D        | RD, RW, WW, TW | R, W         | D             |
  // | RW  | R       | D, W     | RD, RW         | R            | D, W          |
  // | WW  | R, W    | D, W     | RD             | R            | D, W          |
  // | DW  | R, W, D | D, W     | none           | R            | D, W          |
  // | DR  | R, W, D | D, W, R  | none           | none         | D, W, R       |
  // | EX  | R, W, D | D, W, R  | none           | none         | D, W, R       |
  // | TW  | R, W    | D, W     | RD             | R            | D, W          |
  // | TD  | R, W, D | D, W     | none           | R            | D, W          |
  // |==========================================================================|
 
  // German
  // |==========================================================================|
  // |            Obj1          |                      Obj2                     |
  // |--------------------------------------------------------------------------|
  // |LOCK | Garantie | Schutz  | Elaubte LOCKs | Möglichkeiten | Restriktionen |
  // |==========================================================================|
  // | NN  | keine   | keine    | alle           | alle         | keine         |
  // | RD  | R       | D        | RD, RW, WW, TW | R, W         | D             |
  // | RW  | R       | D, W     | RD, RW         | R            | D, W          |
  // | WW  | R, W    | D, W     | RD             | R            | D, W          |
  // | DW  | R, W, D | D, W     | keine          | R            | D, W          |
  // | DR  | R, W, D | D, W, R  | keine          | keine        | D, W, R       |
  // | EX  | R, W, D | D, W, R  | keine          | keine        | D, W, R       |
  // | TW  | R, W    | D, W     | RD             | R            | D, W          |
  // | TD  | R, W, D | D, W     | keine          | R            | D, W          |
  // |==========================================================================|
 
  #ifdef _GLO_TEST
  class __glo_export_dll LockManager
  #else
  class LockManager
  #endif
  {
    public:
      //-----------------------------------------------------------------------
      // >>>>>>>>>>>>>>>>> LockManager::LockedObject >>>>>>>>>>>>>>>>>>>>>>>>>>
      //-----------------------------------------------------------------------
      #ifdef _GLO_TEST
      class __glo_export_dll LockedObject
      #else
      class LockedObject
      #endif
      {
        private:
          //============== Friends
          //-------------------------------------------------------------------
          friend class LockManager;
          //-------------------------------------------------------------------
 
      #ifdef _GLO_TEST
        public:
      #else
        protected:
      #endif
          //-------------------------------------------------------------------
          // >>>> LockManager::LockedObject::CommunicatorRightsRestrictions >>>
          //-------------------------------------------------------------------
          #ifdef _GLO_TEST
          class __glo_export_dll CommunicatorRightsRestrictions
          #else
          class CommunicatorRightsRestrictions
          #endif
          {
            private:
              //============== Friends
              //---------------------------------------------------------------
              friend class LockManager;
              friend class LockedObject;
              //---------------------------------------------------------------
 
          #ifdef _GLO_TEST
            public:
          #else
            protected:
          #endif
              //============== Attribute
              //---------------------------------------------------------------
              TransactionOwner m_CommunicatorWithTreadID;
              //---------------------------------------------------------------
              std::list< DependentObjsWithDeepMode * > m_READvDELETE_Count;
              //---------------------------------------------------------------
              std::list< DependentObjsWithDeepMode * > m_READvWRITE_Count;
              //---------------------------------------------------------------
              std::list< DependentObjsWithDeepMode * > m_WRITEvWRITE_Count;
              //---------------------------------------------------------------
              std::list< DependentObjsWithDeepMode * > m_DELETEvWRITE_Count;
              //---------------------------------------------------------------
              std::list< DependentObjsWithDeepMode * > m_DELETEvREAD_Count;
              //---------------------------------------------------------------
              std::list< DependentObjsWithDeepMode * > m_EXCLUSIVE_Count;
              //---------------------------------------------------------------
              std::list< DependentObjsWithDeepMode * > m_TRANSACTION_WRITE_Count;
              //---------------------------------------------------------------
              std::list< DependentObjsWithDeepMode * > m_TRANSACTION_DELETE_Count;
              //---------------------------------------------------------------
 
            public:
              //============= Konstruktor
              //---------------------------------------------------------------
              CommunicatorRightsRestrictions();
              //---------------------------------------------------------------
              CommunicatorRightsRestrictions( const TransactionOwner & rCommunicatorWithTreadID );
              //---------------------------------------------------------------
              ~CommunicatorRightsRestrictions();
              //---------------------------------------------------------------
 
              //============== Methoden
              //---------------------------------------------------------------
              bool isNULL() const;
              //---------------------------------------------------------------
              bool hasLockREADvDELETE();
              //---------------------------------------------------------------
              bool hasLockREADvWRITE();
              //---------------------------------------------------------------
              bool hasLockWRITEvWRITE();
              //---------------------------------------------------------------
              bool hasLockDELETEvWRITE();
              //---------------------------------------------------------------
              bool hasLockDELETEvREAD();
              //---------------------------------------------------------------
              bool hasLockEXCLUSIVE();
              //---------------------------------------------------------------
              bool hasLockTRANSACTION_WRITE();
              //---------------------------------------------------------------
              bool hasLockTRANSACTION_DELETE();
              //---------------------------------------------------------------
              bool hasReadProtection() const;
              //---------------------------------------------------------------
              bool hasWriteProtection() const;
              //---------------------------------------------------------------
              bool hasDeleteProtection() const;
              //---------------------------------------------------------------
              bool hasReadGuarantee() const;
              //---------------------------------------------------------------
              bool hasWriteGuarantee() const;
              //---------------------------------------------------------------
              bool hasDeleteGuarantee() const;
              //---------------------------------------------------------------
 
            private:
              //---------------------------------------------------------------
              void deleteObjectsInList( std::list< DependentObjsWithDeepMode * > * pList );
              //---------------------------------------------------------------
          };
          //-------------------------------------------------------------------
          // <<<< LockManager::LockedObject::CommunicatorRightsRestrictions <<<
          //-------------------------------------------------------------------
 
      #ifdef _GLO_TEST
        public:
      #else
        protected:
      #endif
          //============== Attribute
          //-------------------------------------------------------------------
          ObjID m_LockObjektID;
          //-------------------------------------------------------------------
          std::map< TransactionOwner, CommunicatorRightsRestrictions *, std::less<TransactionOwner> > m_CommunicatorMap;
          //-------------------------------------------------------------------
 
          //============= Konstruktor
          //-------------------------------------------------------------------
          LockedObject ();
          //-------------------------------------------------------------------
 
        public:
          //============= Konstruktor
          //-------------------------------------------------------------------
          LockedObject (const ObjID & rLockObjekt);
          //-------------------------------------------------------------------
          ~LockedObject ();
          //-------------------------------------------------------------------
 
        private:
          //============= Konstruktor
          //-------------------------------------------------------------------
          LockedObject (const LockedObject &);
          //-------------------------------------------------------------------
 
        public:
          //============== Methoden
          //-------------------------------------------------------------------
          ObjID getObjID () const;
          //-------------------------------------------------------------------
          int lockObject( const TransactionOwner & rCommunicatorWithTreadID,
                          std::stack< ObjID > * pDependObjIdStack,
                          EnLockMode eLockMode,
                          EnDeepMode eDeepMode,
                          bool bSimulate = false );
          //-------------------------------------------------------------------
          int unlockObject( const TransactionOwner & rCommunicatorWithTreadID,
                            std::stack< ObjID > *& prDependObjIdStack,
                            EnLockMode eLockMode,
                            EnDeepMode eDeepMode,
                            bool bSimulate = false );
          //-------------------------------------------------------------------
          bool hasAnyOtherCompetingProtection( const TransactionOwner & rCommunicatorWithTreadID,
                                               EnLockMode eLockMode ) const;
          //-------------------------------------------------------------------
          bool isPossible( const TransactionOwner & rCommunicatorWithTreadID,
                           bool bRead,
                           bool bWrite,
                           bool bDelete) const;
          //-------------------------------------------------------------------
          std::size_t getNumCommunicators();
          //-------------------------------------------------------------------
          void deleteCommunicator( Communicator * pCommunicator );
          //-------------------------------------------------------------------
 
        private:
          //============== Methoden
          //-------------------------------------------------------------------
          int setLocks( CommunicatorRightsRestrictions * pItem,
                        EnLockMode eLockMode,
                        EnDeepMode eDeepMode,
                        std::stack< ObjID > *& prUnlockDependObjIdStack,
                        std::stack< ObjID > * pLockDependObjIdStack,
                        bool bSimulate = false);
          //-------------------------------------------------------------------
          int setLockCount( std::list< DependentObjsWithDeepMode * > & rLockCountList,
                            std::stack< ObjID > *& prUnlockDependObjIdStack,
                            std::stack< ObjID > * pLockDependObjIdStack,
                            EnDeepMode eDeepMode,
                            bool bSimulate = false );
          //-------------------------------------------------------------------
 
        private:
          //============== Operatoren
          //-------------------------------------------------------------------
          LockManager::LockedObject & operator= ( LockedObject & );
          //-------------------------------------------------------------------
      };
      //-----------------------------------------------------------------------
      // <<<<<<<<<<<<<<<<< LockManager::LockedObject <<<<<<<<<<<<<<<<<<<<<<<<<<
      //-----------------------------------------------------------------------
 
    private:
      //============== Attribute
      //-----------------------------------------------------------------------
      std::unordered_map< unsigned long, LockedObject * > m_LockedObjectMap;
      //-----------------------------------------------------------------------
      Manager * m_pDBManager;
      //-----------------------------------------------------------------------
 
    protected:
      //============= Konstruktoren
      //-----------------------------------------------------------------------
      LockManager();
      //-----------------------------------------------------------------------
 
    public:
      //============== De- und Konstruktor
      //-----------------------------------------------------------------------
      LockManager( Manager * pDBManager );
      //-----------------------------------------------------------------------
      virtual ~LockManager();
      //-----------------------------------------------------------------------
 
    private:
      //============== Konstruktoren
      //-----------------------------------------------------------------------
      LockManager( const LockManager & );
      //-----------------------------------------------------------------------
 
    public:
      //============== Method
      //-----------------------------------------------------------------------
      int lockObject( const ObjID & rObjID,
                      std::map< ObjID, Record *, std::less<ObjID> > & rDependObjects,
                      const TransactionOwner & rCommunicatorWithTreadID,
                      const std::string & rsSchemaName,
                      EnLockMode eLockMode,
                      EnDeepMode eDeepMode,
                      bool bSimulate = false );
      //-----------------------------------------------------------------------
      int unlockObject( const ObjID & rObjID,
                        const TransactionOwner & rCommunicatorWithTreadID,
                        const std::string & rsSchemaName,
                        EnLockMode eLockMode,
                        EnDeepMode eDeepMode,
                        bool bSimulate = false );
      //-----------------------------------------------------------------------
      bool isPossible( const ObjID & rObjID,
                       std::map< ObjID, Record *, std::less<ObjID> > & rDependObjects,
                       const TransactionOwner & rCommunicatorWithTreadID,
                       bool bRead,
                       bool bWrite,
                       bool bDelete );
      //-----------------------------------------------------------------------
      LockPossibleSpecification getProcessingPossibilities( const ObjID & rObjID,
                                                            std::map< ObjID, Record *, std::less<ObjID> > & rDependObjects,
                                                            const TransactionOwner & rCommunicatorWithTreadID );
      //-----------------------------------------------------------------------
      void getNotAllowedReadObjects( std::list< ObjID > & rReadLockObjList,
                                     const TransactionOwner & rCommunicatorWithTreadID ) const;
      //-----------------------------------------------------------------------
      #ifdef _GLO_TEST
      std::unordered_map< unsigned long, LockedObject * > & getLockedObjects();
      #endif
      //-----------------------------------------------------------------------
      void deleteAllLocks( Communicator * pCommunicator, const std::string & rsSchemaName );
      //-----------------------------------------------------------------------
 
    private:
      //============== Method
      //-----------------------------------------------------------------------
      void sendNotify( TdWatchNotifyMode nWatchNotifyMode,
                       const ObjID & rObjID,
                       Communicator * pCommunicator,
                       const std::string & rsSchemaName );
      //-----------------------------------------------------------------------
 
    private:
      //============== Operatoren
      //-----------------------------------------------------------------------
      LockManager & operator= ( const LockManager & );
      //-----------------------------------------------------------------------
  };
  //---------------------------------------------------------------------------
} // namespace glo
#endif