---

cObject.cpp

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: ......                                                             */
/*                                                                            */
/******************************************************************************/

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

// Own Header
#include <cObject.h>                    // Database Object class header

// Other POLiTe Header(s)
#include <cObjectBuffer.h>                      // Object Buffer


// The Object is the common ancestor of all classes for objects retrieved
// from the database. Object can represent any projection onto some attributes
// of join of any number of database tables. Instances retrieved from database are not
// persistent. They can be changed, but changes will not be propagated into database.
// Classes derived by the user from this class can be used to access data, resulted
// from any SQL select statement.
//

PROTOTYPE(Object);
//Proto<Object> Object_class;

// Object constructor:
// Create the Object object with the appropriate (NULL) initialization.

Object::Object()
{
        #ifdef C_OBJECT_TRACE
                logmsg("Object::Object() invoked");
        #endif

        _FreeWasDone = false;
        _ForUpdate = false;

        #ifdef C_OBJECT_TRACE
                logmsg("Object::Object() finished");
        #endif
}

// Object destructor:
// Delete the Object object with the appropriate deletion.

// done
Object::~Object()
{
        #ifdef C_OBJECT_TRACE
                logmsg("Object::~DatabaseObject() invoked");
        #endif

        _Free();

        #ifdef C_OBJECT_TRACE
                logmsg("Object::~DatabaseObject() finished");
        #endif
}

bool Object::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.
{
        delete this;
        return true;
};

bool Object::_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.
{
        if (!_FreeWasDone) {
                _FreeWasDone = true;
                if (IsPersistent()) {
                        if (IsDirty())
                                Update();
                        if (MemoryLocked() > 0)
                                throw ObjLibException_MemoryLock();
                        ObjectCache.RemoveObject(this,Connection());
                        };
                };
        return true;
};

//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.

bool Object::Delete()
{
        bool retval = true;

        #ifdef C_OBJECT_TRACE
        logmsg("bool Object::Delete() invoked");
        #endif

        if (IsPersistent())
        {
                if (MemoryLocked())
                        throw ObjLibException_MemoryLock();
                Prototype()->_ExportKeyAttributes(*this);
                Prototype()->_DeleteAll(this);
        }; // Object is deleted from the database

        _MarkAsClean();
        retval = retval && Free();

        #ifdef C_OBJECT_TRACE
        logmsg("bool Object::Delete() finished");
        #endif

        return retval;
}

bool Object::Update()
{
        bool retval = true;

        #ifdef C_OBJECT_TRACE
                logmsg("bool Object::Update() invoked");
        #endif

        if (IsPersistent() && IsDirty()) {
                #ifdef C_OBJECT_TRACE
                        logmsg("Object is dirty");
                #endif

                //Prototype()->_ExportAttributes(*this);
                retval = Prototype()->_UpdateAll(this);
                //_MarkAsClean();
        };

        #ifdef C_OBJECT_TRACE
                logmsg("bool Object::Update() finished");
        #endif

        return retval;
};

//It copies an object from disk to the memory again. Returns true, if it succeed.

bool Object::Refresh()
{
        bool retval;
        bool do_refresh;

        #ifdef C_OBJECT_TRACE
                logmsg("bool Object::Refresh() invoked");
        #endif

        if (IsTransient())
                // Transient instances need not to be refreshed
                do_refresh = false;
        else
                do_refresh = true;

        if (do_refresh)
        {
                retval = Prototype()->_ExportKeyAttributes(*this);
                retval = retval && Prototype()->_Load(*this);
        }
        else
                retval = true;

        #ifdef C_OBJECT_TRACE
                logmsg("bool Object::Refresh() finished");
        #endif

        return (retval);
};

// refresh object only if necessary
bool Object::_Refresh()
{
        bool retval;
        bool do_refresh;

        #ifdef C_OBJECT_TRACE
                logmsg("bool Object::_Refresh() invoked");
        #endif

        if (IsTransient())
                // Transient instances need not to be refreshed
                do_refresh = false;
        else if (Prototype()->IsObject())
                // Object descendants cannot be refreshed
                do_refresh = false;
        else if (_ForUpdate)
                // Instances loaded for update need not to be refreshed
                do_refresh = false;
        else if ((CurrentLockingStrategy()==LS_Exclusive) && !_ForUpdate)
                // Instances that should be locked in database and are not must be reloaded 
                do_refresh = true;
        else if (CurrentReadingStrategy()==RS_Database)
                // Instance should be reloaded
                do_refresh = true;
        else if (CurrentReadingStrategy()==RS_Timestamp)
        {
                // check version of the instance with version in the database
                do_refresh = !_VersionsMatch();
        }
        else
                do_refresh = false;

        if (do_refresh)
        {
                retval = Prototype()->_ExportKeyAttributes(*this);
                retval = retval && Prototype()->_Load(*this);
        }
        else
                retval = true;

        #ifdef C_OBJECT_TRACE
                logmsg("bool Object::_Refresh() finished");
        #endif

        return (retval);
};

//Returns pointer to the unique identification of an object in a database where
//it is stored. It means either true OID (longint) or a tuple of values of primary key.

ObjectIdentification Object::ObjectID() const
{
        #ifdef C_OBJECT_TRACE
        logmsg("ObjectIdentification Object::ObjectID()"
                         " invoked and finished");
        #endif

        if (IsTransient())
                return ObjectIdentification(this);
        else
                return ObjectIdentification(Prototype(),_KeyValues());
}

//Returns Database Pointer to self.

RefBase Object::Address() const
{
        if (IsPersistent())
                return RefBase(Connection(),Prototype(),Prototype()->_KeyValues(*this),_Strategies);
        else
                return RefBase(this);
};

---