---

DbContainerConverter.cpp

Go to the documentation of this file.

//====================================================================
//      DbGenericConverter implementation
//--------------------------------------------------------------------
//
//      Package    : System ( The LHCb Offline System)
//
//  Description: Generic Db data converter
//
//      Author     : M.Frank
//====================================================================
#define DBCNV_DBGENERICCONVERTER_CPP
// $Header: /nfs/slac/g/glast/ground/cvs/GaudiDb/src/Base/DbContainerConverter.cpp,v 1.1.1.1 2001/04/18 21:13:34 tlindner Exp $

#include "GaudiDb/DbDefObject.h"
#include "GaudiDb/DbContainerConverter.h"

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

// STL include files
#include <map>

typedef std::map<CLID,IContainedObjectFactory*> FactoryMap;

DbContainerConverter::DbContainerConverter(const CLID& clid, IOODataBase* db, ISvcLocator* svc)
: DbGenericConverter( clid, db, svc )
{
  m_factories = new FactoryMap();
}

DbContainerConverter::~DbContainerConverter()     {
  FactoryMap* factories = (FactoryMap*)m_factories;
  delete factories;
}

IContainedObjectFactory* DbContainerConverter::objCreator(const CLID& clid)   {
  FactoryMap* factories = (FactoryMap*)m_factories;
  FactoryMap::iterator it = factories->find( clid );
  if( it == factories->end() ) {
    IContainedObjectFactory* fac = locateCreator(clid);
    if ( 0 != fac )   { // Got the proper object factory
      std::pair<FactoryMap::iterator, bool> p = 
        factories->insert(FactoryMap::value_type(fac->clID(), fac) );
      return ( p.second ) ? fac : 0;
    }
    return fac;
  }
  return (*it).second;
}

IContainedObjectFactory* DbContainerConverter::locateCreator(const CLID& clid)   {
  IObjManager* m = m_helperServices.ObjManager;
  IObjManager::ObjIterator i, stop;
  for ( i = m->objBegin(), stop = m->objEnd(); i != stop; i++ )    {
    IFactory* f = const_cast<IFactory*>(*i);
    IContainedObjectFactory* fac = 0;
    StatusCode status = f->queryInterface(IID_IContainedObjectFactory, (void**)&fac);
    if ( status.isSuccess() )   {
      if ( fac->clID() == clid )    {  // Got the proper object factory
        return fac;
      }
    }
  }
  return 0;
}

ContainedObject* DbContainerConverter::createContained(const CLID& clid)   {
  IContainedObjectFactory* cr = objCreator(clid);
  if ( 0 != cr )    {
    return cr->instantiate();
  }
  return 0;
}

StatusCode DbContainerConverter::checkObject( ContainedObject* pObj, const CLID& clid ) {
  if ( 0 == pObj )    {
    MsgStream log(messageService(),"DbContainerConverter");
    log << MSG::ERROR << "Cannot find Object factory for CLID:" << clid << endreq;
    return StatusCode::FAILURE;
  }
  else if ( pObj->clID() != clid )     {
    MsgStream log(messageService(),"DbContainerConverter");
    log << MSG::ERROR << "Cannot update an object of type " << pObj->clID()
        << " with data for an object of type " << clid << endreq;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

StatusCode DbContainerConverter::doPersistentUpdate( dbHandle<DbDefObject>& objH, const DataObject* pObject)    {
  typedef std::vector<const ContainedObject*> ObjArray;
  typedef StreamBuffer::ContainedLinks        CLinks;
  typedef StreamBuffer::IdentifiedLinks       ILinks;
  try   {
    StatusCode status = DbGenericConverter::doPersistentUpdate(objH, pObject);
    const ObjectContainerBase* pCont = dynamic_cast<const ObjectContainerBase*>(pObject);
    if ( status.isSuccess() && 0 != pCont )   {
      StreamBuffer& s = objH->streamBuffer();
      StreamBuffer  tmp;
      unsigned char isunique = 1;
      CLID typ = CLID_NULL;
      CLinks&  t_c = tmp.containedLinks();
      ILinks&  t_i = tmp.identifiedLinks();
      CLinks&  s_c = s.containedLinks();
      ILinks&  s_i = s.identifiedLinks();
      std::vector<const ContainedObject*> objects;
      long numObj = pCont->numberOfObjects();

      for (long j = 0; j < numObj; j++ )   {
        const ContainedObject* obj = pCont->containedObject(j);
        if ( typ == CLID_NULL )   {
          typ = obj->clID();
        }
        else if ( typ != obj->clID() )  {
          isunique = 0;
        }
        objects.push_back(obj);
      }
      s << numObj << isunique;
      if ( isunique )  {
        s << typ;
      }
      for ( ObjArray::iterator i=objects.begin(); i != objects.end(); i++ )   {
        tmp.setMode(StreamBuffer::WRITING);
        tmp.setBuffPointer(0);
        (*i)->serialize(tmp);
        s.extend(3*sizeof(long)+tmp.buffPointer());
        if ( !isunique )   {
          s << (*i)->clID();
        }
        for (ILinks::iterator ii = t_i.begin(); ii != t_i.end(); ii++ )
          s_i.push_back(*ii);
        for (CLinks::iterator jj = t_c.begin(); jj != t_c.end(); jj++ )
          s_c.push_back(*jj);
        s.writeBytes(tmp.data(), tmp.buffPointer());
      }
      return StatusCode::SUCCESS;
    }
  }
  catch(...)    {
  }
  return StatusCode::FAILURE;
}

StatusCode DbContainerConverter::doTransientUpdate( dbHandle<DbDefObject>& objH, DataObject* pObject)    {
  try   {
    StatusCode status = DbGenericConverter::doTransientUpdate(objH, pObject);
    ObjectContainerBase* pCont = dynamic_cast<ObjectContainerBase*>(pObject);
    if ( 0 != pCont && status.isSuccess() )   {
      // OK. Data are read, now update the transient representation(s)
      long i, num = 0, nObj, len = pCont->numberOfObjects();
      StreamBuffer& s = objH->streamBuffer();
      IContainedObjectFactory* cr = 0;
      unsigned char isunique = 1;
      ContainedObject* pObj;
//      ObjIter it;
      CLID clid;
      s >> nObj >> isunique;
      if ( isunique )   {
        s >> clid;
        cr = objCreator(clid);
        if ( 0 == cr )   {
          return StatusCode::FAILURE;
        }
      }
      for ( i = 0; i < nObj; i++ )   {
        if ( !isunique ) {
          s >> clid;
        }
        s >> num; // remainder from write bytes
        if ( i < len )    {
//          pObj = *it;
//          it++;
        }
        else  {
          pObj = (isunique) ? cr->instantiate() : createContained(clid);
          pCont->add( pObj );
        }
        status = checkObject( pObj, clid );
        if ( !status.isSuccess() )    {
          return status;
        }
        pObj->serialize(s);
      }
      for ( num=pCont->numberOfObjects(); i < num; i++ )    {
        ContainedObject* obj = pCont->containedObject(i);
        pCont->release(obj);
      }
      return StatusCode::SUCCESS;
    }
  }
  catch(...)    {
  }
  return StatusCode::FAILURE;
}

---