---

ConversionSvc.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiKernel/src/Lib/ConversionSvc.cpp,v 1.1.1.1 2001/04/18 18:14:18 tlindner Exp $
//====================================================================
//      ConversionSvc.cpp
//--------------------------------------------------------------------
//
//      Package    : System ( The LHCb Offline System)
//
//  Description: implementation of the ConversionSvc
//
//      Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 29/10/98| Initial version                              | MF
// | 29/09/99| Added access to ICnvManager for missing      | MF
// |         | converters                                   | MF
// +---------+----------------------------------------------+---------
//
//====================================================================

#define  PERSISTENCYSVC_CONVERSIONSVC_CPP
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/CnvFactory.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/AddrFactory.h"
#include "GaudiKernel/GenericLink.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/IConverter.h"
#include "GaudiKernel/ICnvManager.h"
#include "GaudiKernel/IDataSelector.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/IDataProviderSvc.h"

#include "GaudiKernel/ConversionSvc.h"

StatusCode ConversionSvc::initialize()     {
  StatusCode status = Service::initialize();
  if ( status.isSuccess() )   {
    status = serviceLocator()->queryInterface(IID_ICnvManager, (void**)&m_cnvManager);
    if ( !status.isSuccess() )    {
      return status;
    }
  }
  return status;
}

StatusCode ConversionSvc::finalize()      {
  m_cnvManager = 0;
  return Service::finalize();
}

StatusCode ConversionSvc::updateServiceState(IOpaqueAddress*)    {
  return StatusCode::SUCCESS;
}

StatusCode ConversionSvc::createObj(IOpaqueAddress* pAddress, DataObject*& refpObject)  
{
  const CLID&  obj_class = pAddress->clID();
  IConverter*  cnv       = converter(obj_class);
  StatusCode   status    = NO_CONVERTER;
  if ( 0 != cnv )   {
    status = updateServiceState(pAddress);
    if ( status.isSuccess() )  {
      status = cnv->createObj(pAddress, refpObject);
      if ( status.isSuccess() )  {
        status = m_dataSvc->updateRegistryEntry(pAddress, refpObject);
        if ( status.isSuccess() )  {
          status = cnv->fillObjRefs(pAddress, refpObject);
          if ( status.isSuccess() )  {
            status = m_dataSvc->updateRegistryEntry(pAddress, refpObject);
            return status;
          }
        }
      }
    }
  }
  refpObject = 0;
  // on fatal errors throw exception
  return status;
}

StatusCode ConversionSvc::updateObj(IOpaqueAddress* pAddress, DataObject* pObject)  
{
  const CLID&  obj_class = pAddress->clID();
  IConverter*  cnv = converter(obj_class);
  StatusCode   status    = NO_CONVERTER;
  if ( 0 != cnv )   {
    status = updateServiceState(pAddress);
    if ( status.isSuccess() )  {
      status = cnv->updateObj(pAddress, pObject);
      if ( status.isSuccess() )  {
       status = cnv->updateObjRefs(pAddress, pObject);
        if ( status.isSuccess() )  {
          status = m_dataSvc->updateRegistryEntry(pAddress, pObject);
          return status;
        }
      }
    }
  }
  // on fatal errors throw exception
  return status;
}

StatusCode ConversionSvc::updateReps(IDataSelector* pSelector)  {
  Context::iterator       i;
  IDataSelector::iterator j;
  Context                 context;
  StatusCode              status = NO_CONVERTER;
  StatusCode              iret   = StatusCode::SUCCESS;

  // Create context
  for ( j = pSelector->begin(); j != pSelector->end(); j++ )   {
    IOpaqueAddress* addr = (*j)->address();
    if ( 0 != addr )  {
      unsigned char type = addr->svcType();
      if ( type == repSvcType() )   {            // Yes! I have to do the job!
        const CLID& obj_class = (*j)->clID();
        IConverter* cnv = converter(obj_class);
        // Push pointer independent of actual value!
        context.push_back(ContextEntry(cnv, addr, (*j)));
        if ( 0 == cnv )   {
          iret = NO_CONVERTER;
        }
      }
      else    {
        iret = BAD_STORAGE_TYPE;
      }
    }
  }
  // Update primitive representation
  for ( i = context.begin(); i != context.end(); i++ )   {
    ContextEntry& e = (*i);
    if ( 0 != e.converter() )  {
      status = e.converter()->updateRep(e.address(), e.object());
      if ( !status.isSuccess() )    {
        iret = status;
      }
    }
  }
  // Finally update local representation references which are unknown to the data model
  for ( i = context.begin(); i != context.end(); i++ )   {
    ContextEntry& e = (*i);
    if ( 0 != e.converter() )  {
      status = e.converter()->updateRepRefs(e.address(), e.object());
      if ( !status.isSuccess() )    {
        iret = status;
      }
    }
  }
  return iret;
}

StatusCode ConversionSvc::createReps(IDataSelector* pSelector)  {
  MsgStream log(msgSvc(), name());
  Context::iterator       i;
  IDataSelector::iterator j;
  Context                 context;
  StatusCode              status = NO_CONVERTER;
  StatusCode              iret   = StatusCode::SUCCESS;
  // Create context
  for ( j = pSelector->begin(); j != pSelector->end(); j++ )   {
    const CLID&    obj_class = (*j)->clID();
    IConverter*    cnv = converter(obj_class);
    if ( 0 == cnv )   {
      log << MSG::INFO << "no converter for object "
          << System::typeinfoName(typeid(**j)) << "  CLID= " << obj_class
          << endreq;
      iret = NO_CONVERTER;
    } else {
      context.push_back(ContextEntry(cnv, (*j)->address(), (*j)));
    }
  }
  // Update primitive representation
  for ( i = context.begin(); i != context.end(); i++ )   {
    ContextEntry& e = (*i);
    if ( 0 != e.converter() )  {
      status = e.converter()->createRep(e.object(), e.address());
      if ( status.isSuccess() )  {
        status = m_dataSvc->updateRegistryEntry(e.address(), e.object());
        if ( !status.isSuccess() )  {
          iret = status;
        }
      }
      else  {
        iret = status;
      }
    }
  }
  // Finally update local representation references which are unknown to the data model
  for ( i = context.begin(); i != context.end(); i++ )   {
    ContextEntry& e = (*i);
    // e.address()==0 -> representation was NOT created in the first go!
    if ( 0 != e.converter() && 0 != e.address() )  {
      status = e.converter()->fillRepRefs(e.address(), e.object());
      if ( !status.isSuccess() )  {
        iret = status;
      }
    }
  }
  return iret;
}

const ICnvFactory* ConversionSvc::findCnvFactory(const CLID& wanted)  {
  return (m_cnvManager) ? m_cnvManager->factory(m_type, wanted) : 0;
}

IConverter* ConversionSvc::converter(const CLID& wanted)     {
  IConverter* cnv = 0;
  Workers::iterator i = std::find_if(m_workers->begin(),m_workers->end(),CnvTest(wanted));
  if ( i != m_workers->end() )      {
      cnv = (*i).converter();
  }
  if ( 0 == cnv )     {
    const ICnvFactory* fac = findCnvFactory(wanted);
    if ( 0 != fac )   {
      addConverter(*fac);
      i = std::find_if(m_workers->begin(),m_workers->end(),CnvTest(wanted));
      if ( i != m_workers->end() )      {
          cnv = (*i).converter();
      }
    }
  }
  return cnv;
}

StatusCode ConversionSvc::setStore(IDataProviderSvc* pDataSvc)    {
  // if ( 0 != pDataSvc ) pDataSvc->addRef();     // No...cannot be
  // if ( 0 != m_dataSvc ) m_dataSvc->release();    // No...cannot be
  m_dataSvc = pDataSvc;
  return StatusCode::SUCCESS;
}

StatusCode ConversionSvc::initializeConverter(IConverter* cnv)    {
  if ( cnv )    {
    return cnv->initialize();
  }
  return StatusCode::FAILURE;
}

IConverter* ConversionSvc::createConverter(const ICnvFactory& fac)   {
  return fac.instantiate(serviceLocator());
}

StatusCode ConversionSvc::addConverter(IConverter* pConverter)  {
  const CLID& clid = pConverter->objType();
  removeConverter(clid);
  m_workers->push_back(WorkerEntry(clid, pConverter));
  pConverter->addRef();
  initializeConverter( pConverter );
  return StatusCode::SUCCESS;
}

StatusCode ConversionSvc::addConverter(const ICnvFactory& refFactory)  {
  IConverter* pConverter = createConverter(refFactory);
  unsigned char   typ    = pConverter->repSvcType();
  if ( typ == repSvcType() )    {
    return addConverter(pConverter);
  }
  pConverter->release();
  return StatusCode::FAILURE;
}

StatusCode ConversionSvc::removeConverter(const CLID& clid)  {
  CnvTest test(clid);
  Workers::iterator stop  = m_workers->end();
  Workers::iterator start = m_workers->begin();
  for(Workers::iterator i=start; i != stop; i++ )    {
    if ( test( *i ) )   {
      (*i).converter()->release();
    }
  }
  Workers::iterator j = std::remove_if(start, stop, test);
  if ( j != stop )  {
    m_workers->erase(j, stop);
    return StatusCode::SUCCESS;
  }
  return NO_CONVERTER;  
}

StatusCode ConversionSvc::queryInterface(const IID& riid, void** ppvInterface)  {
  if ( IID_IConversionSvc == riid )  {
    *ppvInterface = (IConversionSvc*)this;
  }
  else if ( IID_IAddressCreator == riid )  {
    *ppvInterface = (IAddressCreator*)this;
  }
  else  {
    // Interface is not directly availible: try out a base class
    return Service::queryInterface(riid, ppvInterface);
  }
  addRef();
  return StatusCode::SUCCESS;
}

unsigned char ConversionSvc::repSvcType() const {
  return m_type;
}

StatusCode ConversionSvc::connectOutput(const std::string&) {
  return StatusCode::SUCCESS;
}

StatusCode ConversionSvc::setAddressCreator(IAddressCreator* creator)   {
  m_addressCreator = creator;
  return StatusCode::SUCCESS;
}

StatusCode ConversionSvc::createAddress(unsigned char type, 
                                        const CLID& classId,
                                        const std::string& dbName, 
                                        const std::string& contName, 
                                        int seqId,
                                        IOpaqueAddress*& refpAddress)    {
  refpAddress = 0;
  if ( type == repSvcType() && 0 != m_addressFactory )   {
    refpAddress = m_addressFactory->instantiate(classId, dbName, contName, seqId);
    return (0==refpAddress) ? StatusCode::FAILURE : StatusCode::SUCCESS;
  }
  return BAD_STORAGE_TYPE;
}

StatusCode ConversionSvc::createAddress(const GenericLinkBase& link, 
                                        const std::string& dbName, 
                                        const std::string& contName, 
                                        const std::string& objName, 
                                        IOpaqueAddress*& refpAddress)    {
  refpAddress = 0;
  if ( link.svcType() == repSvcType() && 0 != m_addressFactory )   {
    refpAddress = m_addressFactory->instantiate(link, dbName, contName, objName);
    return (0==refpAddress) ? StatusCode::FAILURE : StatusCode::SUCCESS;
  }
  return BAD_STORAGE_TYPE;
}

ConversionSvc::ConversionSvc(const std::string& name, ISvcLocator* svc, unsigned char type)
 : Service(name, svc)
{
  m_type            = type;
  m_dataSvc         = 0;
  m_cnvManager      = 0;
  m_addressFactory  = 0;
  m_workers = new Workers();
}

ConversionSvc::~ConversionSvc()   {
  // Release all workers.
  for ( Workers::iterator i = m_workers->begin(); i != m_workers->end(); i++ )    {
    (*i).converter()->release();
  }
  m_workers->erase(m_workers->begin(), m_workers->end() );
  delete m_workers;
}

---