---

DbGenericConverter.cpp

Go to the documentation of this file.

//====================================================================
//      DbGenericConverter implementation
//--------------------------------------------------------------------
//
//      Package    : System ( The LHCb Offline System)
//
//  Description: Generic Db data converter
//
//  Object layout:
//  ------------------------------------------------------------
//  Base Object: DataObject's Leafs
//  Base Object: DataObject's Links
//  ------------------------------------------------------------
//  Contained  links
//  Identified links
//  Object data
//
//  I know that this code lokks VERY ugly. However, since a major
//  part of the data consists out of contained or identified links
//  between objects, this part was tried to be optimized.
//
//
//
//      Author     : M.Frank
//====================================================================
#define DBCNV_DBGENERICCONVERTER_CPP
// $Header: /nfs/slac/g/glast/ground/cvs/GaudiDb/src/Base/DbGenericConverter.cpp,v 1.1.1.1 2001/04/18 21:13:35 tlindner Exp $

#include "GaudiDb/DbOOMs.h"
#include "GaudiDb/IOODataBase.h"
#include "GaudiDb/DbContainer.h"
#include "GaudiDb/DbDefObject.h"
#include "GaudiDb/DbGenericConverter.h"

#include "GaudiKernel/StreamBuffer.h"
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/ObjectContainerBase.h"

inline bool __WRITE__(char mask, StreamBuffer& buf, long item)   {
  switch(mask)    {
  case 1:  buf << char (item);   return true;
  case 2:  buf << short(item);   return true;
  case 3:  buf << long (item);   return true;
  default:                       return false;
  }
}

inline bool __READ__(char mask, StreamBuffer& buf, long& item)   {
  switch(mask)    {
  case 1:  { char  ___i; buf >> ___i; item = ___i;  return true; }
  case 2:  { short ___i; buf >> ___i; item = ___i;  return true; }
  case 3:  {             buf >> item;               return true; }
  default: {                                       return false; }
  }
}

DbGenericConverter::DbGenericConverter(const CLID& clid, IOODataBase* db, ISvcLocator* svc)
: DbBaseConverter( clid, db, svc )
{
  std::string typName = System::typeinfoName(typeid(DbDefObject));
  m_type = db->typeInfo(typName);
}

DbGenericConverter::~DbGenericConverter()     {
}

dbHandle<DbObject> DbGenericConverter::createPersistent(dbHandle<DbContainer>& cntH)  {
  dbHandle<DbObject> handle = new(cntH, *m_type) DbDefObject();
  return handle;
}

void DbGenericConverter::clearBuffers(dbHandle<DbDefObject>& objH )   {
  StreamBuffer& objBuf = objH->streamBuffer();
  StreamBuffer& lnkBuf = objH->linkBuffer();
  // Setup object data buffer
  objBuf.setMode(StreamBuffer::WRITING);
  objBuf.setBuffPointer(0);
  // Setup link buffer
  lnkBuf.setMode(StreamBuffer::WRITING);
  lnkBuf.setBuffPointer(0);
}

StatusCode DbGenericConverter::beginPersistentUpdate( DefHandle& objH, const DataObject* /* pObject */ )   {
  clearBuffers(objH);
  return StatusCode::SUCCESS;
}

StatusCode DbGenericConverter::endPersistentUpdate( DefHandle& objH, const DataObject* pObject)   {
  typedef StreamBuffer::ContainedLinks        CLinks;
  typedef StreamBuffer::IdentifiedLinks       ILinks;
  StreamBuffer& objBuf = objH->streamBuffer();
  CLinks& c_links = objBuf.containedLinks();
  ILinks& i_links = objBuf.identifiedLinks();

  // First serialize the entire object
  objH->setObjSize (objBuf.buffPointer());
  if ( c_links.size() > 0 || i_links.size() > 0 )   {
    StreamBuffer& linkBuf = objH->linkBuffer();
    CLinks::iterator i, end;
    ILinks::iterator j;
    DataObject* pD;
    const long INVALID = StreamBuffer::INVALID;
    long linkMax = 0, hintMax = 0, num, k;
    char linkMask, hintMask;
    num = (i_links.size() > c_links.size()) ? i_links.size() : c_links.size();
    long* hints = new long[num];
    long* links = new long[c_links.size()];
    // Need to protect memory allocation against failures!
    try   {
      // Second: Serialize all links to contained objects (type ContainedObject)
      const ObjectContainerBase* last_par = 0;
      long last_hint = INVALID;
      std::string path;
      for (num = c_links.size()-1, i = c_links.begin(), end = c_links.end(); i != end; i++ )    {
        hints[num] = links[num] = INVALID;
        if ( 0 != (*i).first && 0 != (*i).first->parent() )    {
          const ObjectContainerBase* par = (*i).first->parent();
          if ( par != last_par )    {
            last_par = par;
            path = par->fullpath();
            last_hint = pObject->addLink(path, par);
            if ( last_hint > hintMax ) hintMax = last_hint;
          }
          hints[num] = last_hint;
          links[num] = last_par->distance((*i).first);
          if ( links[num] > linkMax ) linkMax = links[num];
        }
        num--;
      }
      num  = c_links.size();
      (linkBuf) << num;
      if ( num > 0 )   {
        hintMask = (hintMax < SCHAR_MAX) ? 1 : (hintMax < SHRT_MAX) ? 2 : 3;
        linkMask = (linkMax < SCHAR_MAX) ? 1 : (linkMax < SHRT_MAX) ? 2 : 3;
        (linkBuf) << hintMask << linkMask;
        for ( k = 0; k < num; k++ )   {
          if ( !__WRITE__(hintMask, linkBuf, hints[k]) )
            goto Error;
          if ( !__WRITE__(linkMask, linkBuf, links[k]) )
            goto Error;
        }
      }
      // Second: Serialize all links to identified objects (type DataObject) 
      for (j = i_links.begin(), num = 0; j != i_links.end(); j++)    {
        pD = (*j).first;
        hints[num] = (0 == pD) ? INVALID : pObject->addLink(pD->fullpath(), pD);
        if ( hints[num] > hintMax ) hintMax = hints[num];
        num++;
      }
      num = i_links.size();
      (linkBuf) << num;
      if ( num > 0 )    {
        hintMask = (hintMax < SCHAR_MAX) ? 1 : (hintMax < SHRT_MAX) ? 2 : 3;
        (linkBuf) << hintMask;
        for ( k = 0; k < num; k++ )   {
          if ( !__WRITE__(hintMask, linkBuf, hints[k]) )
            goto Error;
        }
      }
      goto Done;
    }
    catch(...)    {
    }
  Error:
      delete links;
      delete hints;
      return StatusCode::FAILURE;
  Done:
    delete links;
    delete hints;
  }
  return StatusCode::SUCCESS;
}

StatusCode DbGenericConverter::doPersistentUpdate( dbHandle<DbDefObject>& objH, const DataObject* pObject)    {
  StreamBuffer& objBuf = objH->streamBuffer();
  objBuf << pObject->clID();
  pObject->serialize(objBuf);
  return StatusCode::SUCCESS;
}

StatusCode DbGenericConverter::beginTransientUpdate( dbHandle<DbDefObject>& objH, DataObject* pObject)    {
  ObjectContainerBase* pCont;
  DataObject::Link* link;
  ContainedObject* pContained;
  StreamBuffer& objBuf = objH->streamBuffer();

  objBuf.reserve(objH->objSize());
  objBuf.setMode(StreamBuffer::READING);
  objBuf.setBuffPointer(0);
  if ( objH->linkSize() > 0 )   {
    StreamBuffer& linkBuf = objH->linkBuffer();
    const long INVALID = StreamBuffer::INVALID;
    long i, hint_id, link_id, numContd, numIdent;
    char linkMask, hintMask;
    linkBuf.setMode(StreamBuffer::READING);
    linkBuf.reserve(objH->linkSize());
    linkBuf.setBuffPointer(0);
    linkBuf >> numContd;
    if ( numContd > 0 )   {
      (linkBuf) >> hintMask >> linkMask;
      objBuf.containedLinks().reserve ( numContd );
      // First: de-serialize links to contained objects
      for ( i = 0; i < numContd; i++ )      {
        if ( !__READ__(hintMask, linkBuf, hint_id) || 
             !__READ__(linkMask, linkBuf, link_id) ) 
             goto Error;
        if ( INVALID == link_id || INVALID == hint_id )   {
          objBuf.addContainedLink(0, INVALID, INVALID);
        }
        else  {
          link = pObject->symLink(hint_id);
          DataObject* linkObj = (link) ? link->object() : 0;
          pContained = 0;
          if ( 0 != linkObj )    {
            try   {
              pCont = dynamic_cast<ObjectContainerBase*>(linkObj);
              if ( 0 != pCont )    {
                pContained = pCont->containedObject(link_id);
              }
            }
            catch(...)    {
            }
          }
          objBuf.addContainedLink(pContained, hint_id, link_id);
        }
      }
    }
    linkBuf >> numIdent;
    if ( numIdent > 0 )   {
      (linkBuf) >> hintMask;
      objBuf.identifiedLinks().reserve( numIdent );
      // Second: de-serialize links to identified objects
      for ( i = 0; i < numIdent; i++ )      {
        if ( !__READ__(hintMask, linkBuf, hint_id) )
          goto Error;
        if ( INVALID == hint_id )   {
          objBuf.addIdentifiedLink(0, INVALID);
        }
        else    {
          link = pObject->symLink(hint_id);
          objBuf.addIdentifiedLink((link) ? link->object() : 0, hint_id);
        }
      }
    }
  }
  return StatusCode::SUCCESS;
Error:
  return StatusCode::FAILURE;
}

StatusCode DbGenericConverter::endTransientUpdate( dbHandle<DbDefObject>& /* objH */ , DataObject* /* pObject */ )    {
  return StatusCode::SUCCESS;
}

StatusCode DbGenericConverter::doTransientUpdate( dbHandle<DbDefObject>& objH, DataObject* pObject)    {
  if ( 0 != pObject && objH.isValid() )   {
    StreamBuffer& s = objH->streamBuffer();
    CLID clid;
    s >> clid;
    if ( clid == pObject->clID() )    {
      pObject->serialize(s);
      return StatusCode::SUCCESS;
    }
  }
  return StatusCode::FAILURE;
}

---