---

DbObject.cpp

Go to the documentation of this file.

//====================================================================
//      DbObject implementation
//--------------------------------------------------------------------
//
//      Package    : System ( The LHCb Offline System)
//
//  Description: Generic data persistency
//
//      Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 11/07/99| Initial version                              | MF
// +---------+----------------------------------------------+---------
//====================================================================
#define DBCNV_DBOBJECT_CPP 1
// $Header: /nfs/slac/g/glast/ground/cvs/GaudiDb/src/Base/DbObject.cpp,v 1.1.1.1 2001/04/18 21:13:35 tlindner Exp $

// STL include files
#include <iostream>

// Framework include files
#include "GaudiKernel/System.h"
#include "GaudiDb/IOODataBase.h"
#include "GaudiDb/DbVArray.h"
#include "GaudiDb/DbObject.h"
#include "GaudiDb/DbHandle.h"
#include "GaudiDb/DbPersistent.h"
#include "GaudiDb/DbTypeInfo.h"
#include "GaudiDb/DbContainer.h"
#include "GaudiDb/DbDataBase.h"
//##############################################

static long s_numDbObjectInstances = 0;

// Static object creator
DbObject* DbObject::create(void* buffer)    {
  return ::new(buffer) DbObject();
}

// New operator
void* DbObject::operator new(size_t size, const DbTypeInfo& type)   {
  dbHandle<DbContainer> cntH;
  return DbObject::operator new(size, cntH, type);
}

// New operator
void* DbObject::operator new(size_t size)   {
  DbObject* ptr = (DbObject*)::operator new(size);
  ptr->m_internals.m_guard = DbPersistent::createGuard();
  return ptr;
}

void* DbObject::operator new(size_t /* size */ , dbHandle<DbContainer>& cntH, const DbTypeInfo& type)       {
  if ( cntH.isValid() && cntH.type() == type.type() )    {
    return DbPersistent::allocate(cntH, type);
  }
        throw std::bad_alloc();
}

void DbObject::operator delete(void* ptr)   {
  DbObject*          o = (DbObject*)ptr;
  DbPersistentGuard* g = o->m_internals.m_guard;
  DbPersistent*      p = g->persistent();
  if ( 0 != p )   {
    p->release();
  }
  ::delete (char*)ptr;
  ::delete g;
}

void DbObject::operator delete(void *ptr, const DbTypeInfo& /* info */ )   {
  DbObject::operator delete(ptr);
}

void DbObject::operator delete(void *ptr, dbHandle<DbContainer>& /* cntHdl */ , const DbTypeInfo& /* info */ )    {
  DbObject::operator delete(ptr);
}

bool DbObject::deleteObject()   {
  DbPersistentGuard* g = m_internals.m_guard;
  DbPersistent*      p = g->persistent();
  // Delete persistent representation or release memory
  if ( 0 != p )   {
    delete p;
  }
  // Destruct the object
  ::delete this;
  ::delete g;
  return true;
}

// Standard constructor
DbObject::DbObject()   {
  increaseCounter();
}

// Standard destructor
DbObject::~DbObject()   {
  decreaseCounter();
}

void DbObject::decreaseCounter()    {
  s_numDbObjectInstances--;
}

void DbObject::increaseCounter()    {
  s_numDbObjectInstances++;
}

StreamBuffer& DbObject::streamBuffer()     {
  return m_internals.m_guard->objBuffer();
}

StreamBuffer& DbObject::linkBuffer()     {
  return m_internals.m_guard->linkBuffer();
}

unsigned char DbObject::storageType()   const     {
  return m_internals.m_guard->type();
}

bool DbObject::isPersistent()   const   {
  return m_internals.m_guard->type() != TEST_StorageType;
}

long DbObject::numLink()    const      {
  return m_internals.m_guard->links().size();
}

dbVarray< dbHandle<DbLink> >& DbObject::links()   {
  return m_internals.m_guard->links();
}

const dbVarray< dbHandle<DbLink> >& DbObject::links()  const   {
  return m_internals.m_guard->links();
}

long DbObject::bufferSize() const  {
  return m_internals.m_guard->size();
}
long DbObject::objSize()  const   {
  return m_internals.m_guard->objectSize();
}
void DbObject::setObjSize(long length)    {
  m_internals.m_guard->setObjectSize(length);
}

long DbObject::numInstances()    {
  return s_numDbObjectInstances;
}

long DbObject::addRef()    {
  DbPersistentGuard* g = m_internals.m_guard;
  return g->addRef();
}

long DbObject::release()   {
  DbPersistentGuard* g = m_internals.m_guard;
  long cnt = g->release();
  if ( cnt <= 0 )   {
    delete this;
  }
  return cnt;
}

DbResult DbObject::addAssocEntry(const std::string& db, const std::string& cnt, const std::string& obj, dbHandle<DbLink>& to)   {
  dbHandle<DbObject> objH = this;
  dbHandle<DbDataBase> dbH = objH.containedIn().containedIn();
  return dbH.addAssocEntry(db, cnt, obj, to);
}

long DbObject::addLink(const std::string& db, const std::string& cnt, const std::string& obj, const dbHandle<DbLink>& to)    {
  dbHandle<DbLink> internal_to(to);
  //std::cout << "Add leaf:" << obj << " #Links:" << m_objLinks.size() << " #Leafs:" << m_objSymLinks.size() << std::endl;
  if ( addAssocEntry(db, cnt, obj, internal_to) )   {
    return links().extend(internal_to);
  }
  links().extend(internal_to);
  return DbOOMs::DbError;
}

long DbObject::addInvalidLink()    {
  GenericLinkBase lnk;
  links().extend(lnk);
  return DbOOMs::DbSuccess;
}

void DbObject::badAssignMessage()   {
    std::cout << System::moduleName() 
              << "--> DbCnv::DbObject> "
              << "Tried to assign bad Pointer to Accessor!" << std::endl;
}

---