---

cObjectBuffer.h

Go to the documentation of this file.

/******************************************************************************/
/*                                                                            */
/* POLiTe - Persistent Object Library Test                                    */
/*                                        Ph.D. Thesis by Mgr. Michal Kopecky */
/*                                                                            */
/* Charles University Prague                                                  */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* File name: ...                                                             */
/* Module: ......                                                             */
/*                                                                            */
/******************************************************************************/

#ifndef __C_OBJECTBUFFER_H__
#define __C_OBJECTBUFFER_H__

// Common POLiTe Header(s)
#include <lDefs.h>
#include <lTypes.h>
#include <lExceptions.h>

extern DLL_External class ObjectBuffer ObjectCache;

class DLL_External ObjectBuffer
{
#ifdef POLITE_TEST_FRIEND
        friend POLITE_TEST_FRIEND;
#endif // POLITE_TEST_FRIEND

friend class Connection;
friend class Database;
friend class RefBase;

protected:
        bool _Initialised;
        bool _ResetForUpdateFlags;
        // If set, UpdateAll resets _ForUpdate flags in objects
        // This is necessary to do, if the connection is commited
        // because locks are then released
        unsigned long int _Requests;
        // Number of requests to object buffer
        unsigned long int _Hits;
        // Number of hits
        unsigned short _Strategies;
        class BufferItem *_LastAccessedItem;
        class BufferItem *_Structure[MAX_CONNECTION][HASH_TABLE_SIZE];
        unsigned long _ObjectsInBuffer;

        unsigned long _GarbageCollector();
        // returns the number of the objects removed from the buffer
        unsigned int _Hash(const char *values) const;
        class BufferItem * _FindItem(const class RefBase &DbPtr);
        // similar to IsInMemory, instead databasepointer returns bufferitem
        bool _RemoveConnection (int ConHandle);
        // similar to _RemoveAll(Connection), instead pointer to database connection
        // takes handle as a parameter
        bool RemoveConnection (int ConHandle);
        // similar to RemoveAll(Connection), instead pointer to database connection
        // takes handle as a parameter
        // Differently from _RemoveConnection does some additional tests
        bool UpdateConnection (int ConHandle);
        // see above (Connection) and below (Update)

public:
        ObjectBuffer(); // Init() from the specification

        ~ObjectBuffer(); // Close() from the specification

        bool Init(
                const enum LockingStrategy aLockingStrategy,
                const enum UpdatingStrategy anUpdateStrategy,
                const enum WaitingStrategy aWaitingStrategy
                );

        class Object *IsInMemory(
                const class RefBase &DbPtr
                );
        // If the object is in the internal data structure, the pointer
        // to it is returned, otherwise NULL
        // If the RefBase contains NULL as memory pointer or
        // database connection, the exception is thrown

        bool RegisterObject(
                const class RefBase &DbPtr,
                const class Object *const MemPtr
                );
        // Is called, when the newly created object is made persistent
        // or whenever the buffer loads object to the memory

        bool RemoveObject(
                class Object *MemPtr,
                const class Connection * const DbCon);
        // The corresponding buffer item is freed from the memory.
        // Is called by DatabaseObject.Delete or Free

        bool RemoveObject(const class RefBase &DbPtr);
        // The corresponding buffer item is freed from the memory.
        // Is called by DatabaseObject.Delete or Free

        // All dirty objects are written to the database.
        bool UpdateAll();
        bool UpdateAll(const class Connection *const DbC);
        bool UpdateAll(const class Database *const DB);

        // All the objects are freed from the memory
        bool RemoveAll();
        bool RemoveAll(const class Connection *const DbC);
        bool RemoveAll(const class Database *const DB);

        // Get and set corresponging patrs of attribute _Strategies
        // that holds all concurency strategies
        virtual enum UpdatingStrategy CurrentUpdatingStrategy() const
        // Returns Update Strategy part of attribute _Strategies
        {
                return (enum UpdatingStrategy)(_Strategies & US_MASK);
        };
        virtual bool SetUpdatingStrategy(enum UpdatingStrategy anUpdateStrategy);
        virtual enum WaitingStrategy CurrentWaitingStrategy() const
        {
                return (enum WaitingStrategy)(_Strategies & WS_MASK);
        };
        virtual bool SetWaitingStrategy(enum WaitingStrategy aWaitingStrategy);
        virtual enum LockingStrategy CurrentLockingStrategy() const
        {
                return (enum LockingStrategy)(_Strategies & LS_MASK);
        };
        virtual bool SetLockingStrategy(enum LockingStrategy aLockingStrategy);
        virtual enum ReadingStrategy CurrentReadingStrategy() const
        {
                return (enum ReadingStrategy)(_Strategies & RS_MASK);
        };
        virtual bool SetReadingStrategy(enum ReadingStrategy aReadingStrategy);

protected:
        bool _RemoveAll();
        bool _RemoveAll(const class Connection *const DbC);
        bool _RemoveAll(const class Database *const DB);

public:
//  DatabaseObject *MemoryLock(const class RefBase &const DbPtr);
                                        // Multilevel lock of the object
//  bool MemoryUnlock(const class RefBase &const DbPtr);
                                        // One lock on the object is released

        bool RemoveAllMemoryLocks();
        bool RemoveAllMemoryLocks(class Database &DB);
        bool RemoveAllMemoryLocks(class Connection &DbConn);

        Object *GetReferencedObject(
                const class RefBase &DbPtr
                );
        // From DbPtr recognizes appropriate buffer item
        // then creates empty copy of appropriate object
        // finally fills the copy with values from the database

        //unsigned int MemoryLocked(const class RefBase &const DbPtr);
        // Returns the number of lock on the object

};

#endif //__C_OBJECTBUFFER_H__

---