---

cRefBase.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: ......                                                             */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* An instance of RefBase descendants                                         */
/* points to one object in one specific database.                             */
/* Thus it includes both connection and object identification.                */
/* During the access to the object, the object is automatically dereferenced  */
/* and the object is retrieved (if necessary) from database                   */
/* and placed into the memory.                                                */
/* To minimise the amount of database accesses all persistent objects         */
/* contained currently in memory are registered by the library object buffer  */
/*                                                                            */
/******************************************************************************/

// Own Header
#include <cRefBase.h>   // RefBase class header

// Other POLiTe Header(s)
#include <cObjectIdentification.h>
#include <cObjectBuffer.h>
#include <cObject.h>
#include <cClassRegister.h>

const class RefBase DBNULL;

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

RefBase::RefBase()
: _ObjectIdentification()
{
        #ifdef C_REFBASE_TRACE
                logmsg("RefBase::RefBase() invoked and finished");
        #endif
        _Connection = NULL;
        _Strategies = ObjectCache._Strategies;
}

// RefBase constructor:
// Create the RefBase object with the appropriate initialization.

RefBase::RefBase(
                class Connection *aConnection,
                class ProtoBase *aPrototype,
                char *aSelectKeyValues,
                unsigned short aStrategies
                )
: _ObjectIdentification(aPrototype, aSelectKeyValues)
{
        _Connection = aConnection;
        _Strategies = aStrategies;
        #ifdef C_REFBASE_TRACE
                logmsg("RefBase::RefBase(DatabaseConnection *, Object *, char *) invoked and finished");
        #endif
}

RefBase::RefBase(
        const RefBase &Dbp
        )
: _ObjectIdentification(Dbp._ObjectIdentification)
{
        _Connection = Dbp._Connection;
        _Strategies = Dbp._Strategies;
        #ifdef C_REFBASE_TRACE
                logmsg("RefBase::RefBase(RefBase &) invoked and finished");
        #endif
};

RefBase::RefBase(
        const Object * const DbObj
        )
: _ObjectIdentification(DbObj)
{
        _Connection = NULL;
        if (DbObj)
                _Strategies = DbObj->_Strategies;
        else
                _Strategies = ObjectCache._Strategies;
        #ifdef C_REFBASE_TRACE
                logmsg("RefBase::RefBase(Object *) invoked and finished");
        #endif
};


bool RefBase::Init(
                class Connection *aConnection,
                class ProtoBase *aPrototype,
                char *aSelectKeyValues)
{
        _Connection = aConnection;
        #ifdef C_REFBASE_TRACE
                logmsg("RefBase::_Init(DatabaseConnection *, Object *, char *) invoked and finished");
        #endif
        return _ObjectIdentification._Init(aPrototype, aSelectKeyValues);
}

RefBase::RefBase(
                class Connection *aConnection,
                ObjectIdentification *anIdentification
                )
: _ObjectIdentification(*anIdentification)
{
        _Connection = aConnection;
        #ifdef C_REFBASE_TRACE
                logmsg("RefBase::RefBase(DatabaseConnection *, ObjectIdentification *) invoked and finished");
        #endif
}

RefBase::RefBase(
        class Connection *aConnection,
        const long anOid,
        class ProtoBase *aPrototype
        )
: _ObjectIdentification(anOid, aPrototype)
{
        _Connection = aConnection;
        #ifdef C_REFBASE_TRACE
                logmsg("RefBase::RefBase(DatabaseConnection *, long, ProtoBase *) invoked and finished");
        #endif
}

// RefBase destructor:
// Delete the RefBase object with the appropriate de-initialization.

RefBase::~RefBase()
{
  #ifdef C_REFBASE_TRACE
        logmsg("RefBase::~RefBase() invoked and finished");
        #endif
}

// Typecasts RefBase to class A to RefBase to
// correct A's subclass B. Does nothing in other derived classes.
class RefBase &RefBase::_Virtualise()
{
        char class_name[MAX_CLASS_NAME_LEN + 1];
        char *sqlcmd = NULL;
        class ProtoBase *prot;
        class Connection *dbc;
        bool okay = true;
        #ifdef C_REFBASE_TRACE
                logmsg("RefBase::Virtualise() invoked");
                if (!Prototype()->IsPersistentObject())
                        logmsg(
                                TL_WARNING,
                                "RefBase::Virtualise() used for non PersistentObject based pointer"
                                );
        #endif
        if (
                Prototype()
                && Prototype()->IsPersistentObject()
                && ((dbc = Connection()) != NULL)
                && (_ObjectIdentification._SelectKeyValues != NULL)
                )
        {
                StrCat(sqlcmd,2,
                        "SELECT CLASS_NAME FROM " PERSISTENT_OBJECT_TABLE " WHERE OID = ",
                        _ObjectIdentification._SelectKeyValues
                        );
                okay = okay
                        && dbc->_Open()
                        && dbc->_Prepare(sqlcmd)
                        && dbc->_Execute()
                        && dbc->_PreFetchBind(
                                1,
                                (void *)class_name,
                                MAX_CLASS_NAME_LEN,
                                TYPE_STRING
                                )
                        && dbc->_FetchNext();
                okay = dbc->_Close() && okay;
                StrFree(sqlcmd);
                if (okay)
                {
                        if ((prot = Class[class_name]) != NULL)
                        {
                                // change pointer to the found prototype
                                _ObjectIdentification._prototype = prot;
                        }
                        #ifdef C_REFBASE_TRACE
                        else
                        {
                                logmsg(
                                        TL_WARNING,
                                        "No prototype for class \"%s\" were found",
                                        class_name
                                        );
                        }
                        #endif
                        ;
                };
        };
        return *this;
};

//Returns the reference to the pointed object which will be read from the database,
//if the object is not present in memory yet.

Object &RefBase::ReferencedObject() const
{
        #ifdef C_REFBASE_TRACE
                logmsg("Object &RefBase::ReferencedObject() invoked");
        #endif

        if (*this == DBNULL)
                throw ObjLibException_NotFound();
        return IsPersistent() ? *ObjectCache.GetReferencedObject(*this) : *(Object *)_ObjectIdentification._object;
};

/*
//Returns reference to the pointed object which will be read from the database,
//if object is not present in memory. To load the object a predefined locking
//strategy will be used instead of default one.

Object &RefBase::ReferencedObject(
        const enum LockingStrategy _Locking_Strategy
        ) const
{

        #ifdef C_REFBASE_TRACE
                logmsg("Object &RefBase::ReferencedObject(enum LockingStrategy _Locking_Strategy) invoked");
        #endif

        if (*this == DBNULL)
                throw ObjLibException_NotFound();
        if (Connection() != NULL)
                return *ObjectCache.GetReferencedObject(*this,_Locking_Strategy);
        return *(Object*)_ObjectIdentification._object;
}
*/

//Gives the pointer to the identification of the pointed object (unique in the
//content of the database).

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

  return _ObjectIdentification;
}

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

Object* RefBase::IsInMemory() const
{
  #ifdef C_REFBASE_TRACE
        logmsg("Object* RefBase::IsInMemory() invoked and finished");
        #endif

        if (*this == DBNULL)
                return NULL;
        if (Connection() != NULL)
                return ObjectCache.IsInMemory(*this);
        return (Object*)_ObjectIdentification._object;
}

class ProtoBase *RefBase::Prototype() const
{
  #ifdef C_REFBASE_TRACE
        logmsg("RefBase::Prototype() invoked and finished");
        #endif
        if (*this == DBNULL)
                return NULL;
        return _ObjectIdentification.Prototype();
};

bool RefBase::IsDirty() const
{
        Object *MyDbObject;
        return (MyDbObject=IsInMemory())==NULL ? false : MyDbObject->IsDirty();
};

bool RefBase::MarkAsDirty()
{
        Object *MyDbObject;
        return (MyDbObject=IsInMemory())== NULL ? true : MyDbObject->MarkAsDirty();
};

bool RefBase::_MarkAsClean()
{
        Object *MyDbObject;
        return (MyDbObject=IsInMemory())== NULL ? true : MyDbObject->_MarkAsClean();
};

//Refreshes the pointed object, if it occurs in the memory. Otherwise it does nothing.

bool RefBase::Refresh()
{
        #ifdef C_REFBASE_TRACE
                logmsg("bool RefBase::Refresh() invoked");
        #endif

        Object* MyDbObject;
        return (MyDbObject=IsInMemory())== NULL ? true : MyDbObject->Refresh();
};


// Updates the pointed object, if it occurs in the memory. Otherwise it does nothing.

bool RefBase::Update()
{
        #ifdef C_REFBASE_TRACE
                logmsg("bool RefBase::Update() invoked");
        #endif

        Object* MyDbObject;
        return (MyDbObject=IsInMemory())== NULL ? true : MyDbObject->Update();
};


//Frees the pointed object from the memory, if it occurs there. Otherwise it
//does nothing.

bool RefBase::Free()
{
        #ifdef C_REFBASE_TRACE
                logmsg("bool RefBase::Free() invoked");
        #endif

        Object* MyDbObject;
        return( (MyDbObject=IsInMemory()) == NULL ? true : MyDbObject->Free());
};


bool RefBase::_Free()
{
        #ifdef C_REFBASE_TRACE
                logmsg("bool RefBase::_Free() invoked");
        #endif
        Object* MyDbObject;
        return( (MyDbObject=IsInMemory()) == NULL ? true : MyDbObject->_Free());
};


//Tries to destroy the referenced object from memory, as well as from database.
//Succeed, if all the tests (for example, if object is not locked) are passed
//successfully.

bool RefBase::Delete()
{
        #ifdef C_REFBASE_TRACE
                logmsg("bool RefBase::Delete() invoked");
        #endif

        Object* MyDbObject;
        bool _retval;

        if ((MyDbObject=IsInMemory()) != NULL)
                return MyDbObject -> Delete();
        if (IsTransient())                                      //Object is transient
                return true;
        _retval = Prototype()->_DeleteAll(this);

        #ifdef C_REFBASE_TRACE
                logmsg("bool RefBase::Delete() finished");
        #endif

        return _retval;
};


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

Object *RefBase::MemoryLock()
{
        #ifdef C_REFBASE_TRACE
                logmsg("Object *RefBase::MemoryLock() invoked and finished");
        #endif

        return this->ReferencedObject().MemoryLock();
};

//Unlocks a persistent object in memory. See MemoryLock.
//covered external events:
//· Unlock object in memory

bool RefBase::MemoryUnlock()
{
        Object *MemPtr;
        bool retval;

        #ifdef C_REFBASE_TRACE
                logmsg("bool RefBase::MemoryUnlock() invoked");
        #endif

        retval = ((MemPtr = IsInMemory()) != NULL) ?
                MemPtr -> MemoryUnlock() :
                false;

        #ifdef C_REFBASE_TRACE
                logmsg("bool RefBase::MemoryUnlock() finished");
        #endif

        return retval;
};

//Returns the number of memory locks on receiver or zero
//if it is not locked.

unsigned int RefBase::MemoryLocked() const
{
        unsigned int retval;
        Object *MemPtr;

        #ifdef C_REFBASE_TRACE
                logmsg("unsigned int RefBase::MemoryLocked() invoked");
        #endif

        retval = (
                ((MemPtr = IsInMemory()) == NULL)
                ? 0
                : MemPtr -> MemoryLocked()
                );

        #ifdef C_REFBASE_TRACE
                logmsg("unsigned int RefBase::MemoryLocked() finished");
        #endif

        return retval;
};

//Removes all memory locks existing in the GEN.LIB

bool RefBase::RemoveAllMemoryLocks()
{
        bool retval;
        Object *MemPtr;

        #ifdef C_REFBASE_TRACE
                logmsg("bool RefBase::RemoveAllMemoryLocks() invoked");
        #endif

        retval = (
                ((MemPtr = IsInMemory()) == NULL)
                ? true
                : MemPtr -> RemoveAllMemoryLocks()
                );

        #ifdef C_REFBASE_TRACE
                logmsg("bool RefBase::RemoveAllMemoryLocks() finished");
        #endif

        return retval;
}


bool RefBase::operator == (
        const class RefBase &DbPtr
        ) const
{
        return (this->_Connection == DbPtr._Connection)
                &&(this->_ObjectIdentification == DbPtr._ObjectIdentification);
};

bool RefBase::operator != (
        const class RefBase &DbPtr
        ) const
{
        return (this->_Connection != DbPtr._Connection)
                ||(this->_ObjectIdentification != DbPtr._ObjectIdentification);
};

---