---

cObjRef.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: ......                                                             */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* Abstract common ancestor class of RefBase and Object.              */
/*                                                                            */
/******************************************************************************/

#ifndef __C_OBJREF_H__
#define __C_OBJREF_H__

// Standard Header(s)
#include <stdio.h>

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

// Parent Header(s)
#include <cQueRefProto.h>                       // ObjRefProto class header

//
// Object - Persistent Object Module :
// See Gc_Obj.cpp for the code to the member functions.
//

class DLL_External ObjRef: public QueRefProto
{
#ifdef POLITE_TEST_FRIEND
        friend POLITE_TEST_FRIEND;
#endif // POLITE_TEST_FRIEND

friend class ObjectBuffer;
friend class ProtoBase;

protected:
        unsigned short _Strategies;
        // Holds all four strategies, each in three independent bits
        class Connection *_Connection;       // moved from RefBase class

public:
        ObjRef();                                               // constructor

        virtual ~ObjRef();                              // destructor


protected:
   long int _PtrToOid(const ObjRef &ref) const;
   class RefBase _OidToPtr(
        const long int oid,
           class ProtoBase *prot
      ) const;
   class Object *_OidToMemPtr(
        const long int oid,
           class ProtoBase *prot
      ) const;

public:
// Database Object contents a pointer to Database Connection instead of a pointer to Database
//      virtual class Database *DatabaseID() = 0;       //Returns the pointer to database the object is stored in.

        virtual Object* IsInMemory() const = 0;

        virtual class Connection *Connection() const
        // Returns the pointer to database connection referenced object is
        // (should be) loaded.
        {
                return _Connection;
        };

        virtual class ObjectIdentification ObjectID() const = 0;
        //Returns identification of
        //an object independent on the instance location
        //It consists of either memory pointer,
        //or couple of prototype an comma-separated list of primary key values

        virtual class ProtoBase *Prototype() const = 0;
        // Returns a reference to a prototype instance of the referenced class


public:
        virtual bool IsDirty() const = 0;
        //Returns true, if an object is marked as dirty (e.g. the
        //object was changed in the memory).
        virtual bool MarkAsDirty()      = 0;            
        //Marks a persistent object as Dirty. Only Dirty (changed)
        //objects are written to the database when flushing the buffer.

protected:
        virtual bool _MarkAsClean()     = 0;
        //Marks a persistent object as Clean. Only Dirty (changed)
        //objects are written to the database when flushing the buffer.


public:
        virtual bool Refresh() = 0;
        // It copies an object from disk to the memory again.
        // Returns true, if it succeed.

        virtual bool Update() =0;
        //Writes an object from the memory to the disk.

        virtual bool Free() =0;
        //Tries to destroy an object in the memory only.
        //Succeeds if all the tests
        //(for example, if the object is not locked)
        //are passed successfully.

protected :
        virtual bool _Free() = 0;
        //Destroys an object in the memory. _Free is called by the
        //method Free, if all the tests passed. _Free is not visible
        //for the programmers of the target application.

public:
        virtual bool Delete() = 0;
        //Tries to destroy an object from the memory as well as
        //from the database. Succeeds if all the tests (for
        //example, if the object is not locked) are passed
        //successfully.

        virtual class Object *MemoryLock() = 0;
        //Locks a persistent object. Multiple locks
        //can be placed on the object. The object can be
        //removed from memory only when all the locks are
        //released.

        virtual bool MemoryUnlock() = 0;
        //Unlocks a persistent object in memory. See MemoryLock.

        virtual unsigned int MemoryLocked() const = 0;
        //Returns the number of memory locks on receiver or zero
        //if it is not locked.

        virtual bool RemoveAllMemoryLocks()
        //Removes all memory locks existing in the GEN.LIB
        {
                return true;
        };

        virtual bool IsTransient()      const
        //Returns TRUE if an instance of DatabaseObject is transient,
        //i.e. if it has no copy in database. This can happen if the
        //object was created as transient and was not made persistent
        //by calling BePersistent yet.
        {
                return (Connection() == NULL);
        };

        virtual bool IsPersistent() const
        //Returns TRUE if the object is really persistent, otherwise
        //it returns false. This function returns the opposite value
        //to the method IsTransient.
        {
                return (Connection() != NULL);
        };

        virtual class RefBase BePersistent(class Connection *DbCon) = 0;
        //Causes an object to be persistent.
        //Persistent objects are  created as transient (they exist only
        //in memory) and when it is needed (all attributes are set to
        //appropriate values), then they  can be converted to true
        //persistent objects. An advantage is that transient objects do
        //not propagate into a database while persistent objects are
        //written (in spite of buffering mechanism) to the database
        //often.

        // 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:
        virtual char *_Where() const;
        virtual char *_OrderBy() const {return NULL;};

        virtual char *_KeyValues() const = 0;
        // return comma-separated list of encoded key values
        // encoding allows recognising of ends of individual elements

public:
        virtual bool IsAncestor(const ObjRef &descendant) const;
        // Returns if *this Object is ancestor
        // of *descendant Object
};

#endif //__C_OBJREF_H__

---