---

cObject.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_OBJECT_H__
#define __C_OBJECT_H__

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

// Parent Header(s)
#include <cObjRef.h>

// Other POLiTe Header(s)
#include <cDatabase.h>                                                  // Database class header
#include <cConnection.h>                                        // DatabaseConnection class header
#include <cObjectIdentification.h>                              // ObjectIdentification class header
#include <tProto.h>

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

friend class ObjectBuffer;
friend class RefBase;
friend class ProtoBase;

protected:
        bool _FreeWasDone;
        //There was already called Free() methods on this object
        bool _ForUpdate;
        //Object was loaded using FOR UPDATE

protected:                                                      // member methods
        virtual bool _Free();
        //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:
        Object();                               // constructor

        ~Object();                              // destructor

        static const char* RootClassName() {return NULL;};
        static const char* BaseClassName() {return "Object";};
        ABSTRACT_CLASS(Object);
        //static const char* ClassName() {return "Object";};
        //static const Object * New() {return NULL;};
        //virtual class ProtoBase *Prototype() const = 0
        PARENTS(NULL);
        //static const char* ParentClassNames() {return NULL;};
        FROM("");
        //static const char* From() {return "";};
        WHERE("");
        //static const char* Where() {return "";};
        GROUP_BY("");
        //static const char* GroupBy() {return "";};
        HAVING("");
        //static const char* Having() {return "";};
        ORDER_BY("");
        //static const char* OrderBy() {return "";};
        MAPKEY_BEGIN
        MAPKEY_END;
        MAP_BEGIN
        MAP_END;

public:
        virtual class Object* IsInMemory() const
        //Access to the object with the tests whether the object
        //is loaded into the memory. It returns the pointer to
        //the object in the memory (if he is loaded in the memory)
        //or NULL otherwise.
        {
                return (Object*)this;
                //Object instances are in the memory
                //at least because the method is called on it
        };

        virtual class ObjectIdentification ObjectID() const;
        //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 bool PostLoad() { return true;};
        //Virtual method executed immediately after a database object
        //is loaded from the database. It may be overridden by programmer
        //to provide an additional functionality.

protected:

        virtual bool IsDirty() const { return false; };
        //Returns true, if an object is marked as dirty (e.g. the
        //object was changed in the memory)
        //Object is never dirty

        virtual bool MarkAsDirty()      { return true; };
        //Marks a persistent object as Dirty. Only Dirty (changed)
        //objects are written to the database when flushing the buffer.
        //Object is never dirty

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

        virtual char *_KeyValues() const {return Prototype()->_KeyValues(*this);};

        virtual bool _Refresh();
        // It copies an object from disk to the memory again if necessary
        // If not necessary, does nothing.

public:
        virtual bool Refresh();
        // It copies an object from disk to the memory again.
        // Returns true, if it succeed.
        // Database objects are results of the complex queries
        // and thus can not be refreshed

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

        virtual bool Free();
        //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.

        virtual bool Delete();
        //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()
        //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.
        {
                return this;
                // DataabseObject is everytime in the memory, is bot buffered
                // via ObjectBuffer
        };

        virtual bool MemoryUnlock()
        //Unlocks a persistent object in memory. See MemoryLock.
        {
                return true;
                //No action is necessary on Object
        };

        virtual unsigned int MemoryLocked() const
        //Returns the number of memory locks on receiver or zero
        //if it is not locked.
        {
                return 0;
                // DataabseObject is never locked in memory
        };

        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 true;
                // Object is never realy persistent
        };

        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 false;
                // Object is never realy persistent
        };

public:
        virtual class RefBase BePersistent(class Connection *DbCon)
        //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.
        {
                return Address();
        };

        virtual class RefBase Address() const;
        //Returns Database Pointer to self.

protected:
        virtual class RefBase _Virtualise(RefBase &DbPtr) const
        // Typecasts RefBase to class A to RefBase to
        // correct A's subclass B. Does nothing in other derived classes.
        {
                return DbPtr._Virtualise();
        };

        virtual const char *_SelectKeyValues(const RefBase &DbPtr) const
        // Return this string from given object pointer
        {
                return DbPtr._ObjectIdentification._SelectKeyValues;
        };

        // Checks, if version of object in memory is the same as the version in the database
        // Applicable on PersistentObject class, predecessors return true

        virtual bool _VersionsMatch()
        {
                return true;
        };

};

//ABSTRACT_CLASS_PROTOTYPE(Object);
extern DLL_External Proto<Object> Object_class;


#endif // __C_OBJECT_H__

---