ConversionSvc.cpp

Go to the documentation of this file.

#define  GAUDIKERNEL_CONVERSIONSVC_CPP

#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/CnvFactory.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/IConverter.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/ConversionSvc.h"
#include "GaudiKernel/Converter.h"

enum CnvSvcAction   {
  CREATE_OBJ,
  FILL_OBJ_REFS,
  UPDATE_OBJ,
  UPDATE_OBJ_REFS,
  CREATE_REP,
  FILL_REP_REFS,
  UPDATE_REP,
  UPDATE_REP_REFS
};

StatusCode ConversionSvc::makeCall(int typ,
                                   bool ignore_add,
                                   bool ignore_obj,
                                   bool update,
                                   IOpaqueAddress*& pAddress,
                                   DataObject*& pObject)      {
  if ( 0 != pAddress || ignore_add )    {
    if ( 0 != pObject  || ignore_obj )    {
      const CLID&  obj_class =
        (0 != pObject && !ignore_obj) ? pObject->clID()
        : (0 != pAddress && !ignore_add)
        ? pAddress->clID()
        : CLID_NULL;
      IConverter*  cnv  = converter(obj_class);
      if ( !cnv && pObject ) {
        //Give it a try to autoload the class (dictionary) for which the converter is needed
        loadConverter( pObject);
        cnv  = converter(obj_class);
      }

      StatusCode status(StatusCode::FAILURE,true);
      if ( 0 != cnv )   {
        switch(typ)   {
        case CREATE_OBJ:
          pObject = 0;
          status = cnv->createObj(pAddress, pObject);
          break;
        case FILL_OBJ_REFS:
          status = cnv->fillObjRefs(pAddress, pObject);
          break;
        case UPDATE_OBJ:
          status = cnv->updateObj(pAddress, pObject);
          break;
        case UPDATE_OBJ_REFS:
          status = cnv->updateObjRefs(pAddress, pObject);
          break;
        case CREATE_REP:
          pAddress = 0;
          status = cnv->createRep(pObject, pAddress);
          break;
        case FILL_REP_REFS:
          status = cnv->fillRepRefs(pAddress, pObject);
          break;
        case UPDATE_REP:
          status = cnv->updateRep(pAddress, pObject);
          break;
        case UPDATE_REP_REFS:
          status = cnv->updateRepRefs(pAddress, pObject);
          break;
        default:
          status = StatusCode::FAILURE;
          break;
        }
        if ( status.isSuccess() && update )   {
          status = updateServiceState(pAddress);
        }
        return status;
      }
      status.ignore();
      MsgStream log(msgSvc(), name());
      log << MSG::INFO << "No converter for object ";
      if ( pObject != 0 )   {
        log << System::typeinfoName(typeid(*pObject));
      }
      log << "  CLID= " << obj_class << endmsg;
      return NO_CONVERTER;
    }
    return INVALID_OBJECT;
  }
  return INVALID_ADDRESS;
}

void ConversionSvc::loadConverter(DataObject*) {

}

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

StatusCode ConversionSvc::createObj(IOpaqueAddress* pAddress, DataObject*& refpObj)   {
  return makeCall(CREATE_OBJ, false, true, false, pAddress, refpObj);
}

StatusCode ConversionSvc::fillObjRefs(IOpaqueAddress* pAddress, DataObject* pObj)    {
  return makeCall(FILL_OBJ_REFS, false, true, true, pAddress, pObj);
}

StatusCode ConversionSvc::updateObj(IOpaqueAddress* pAddress, DataObject* pObj)   {
  return makeCall(UPDATE_OBJ, false, true, false, pAddress, pObj);
}

StatusCode ConversionSvc::updateObjRefs(IOpaqueAddress* pAddress, DataObject* pObj)  {
  return makeCall(UPDATE_OBJ_REFS, false, true, true, pAddress, pObj);
}

StatusCode ConversionSvc::createRep(DataObject* pObj, IOpaqueAddress*& refpAddress)  {
  return makeCall(CREATE_REP, true, false, false, refpAddress, pObj);
}

StatusCode ConversionSvc::fillRepRefs(IOpaqueAddress* pAddress, DataObject* pObj)  {
  return makeCall(FILL_REP_REFS, true, false, false, pAddress, pObj);
}

StatusCode ConversionSvc::updateRep(IOpaqueAddress* pAddress, DataObject* pObj)  {
  return makeCall(UPDATE_REP, true, false, false, pAddress, pObj);
}

StatusCode ConversionSvc::updateRepRefs(IOpaqueAddress* pAddress, DataObject* pObj)    {
  return makeCall(UPDATE_REP_REFS, true, false, false, pAddress, pObj);
}

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

StatusCode ConversionSvc::setDataProvider(IDataProviderSvc* pDataSvc)    {
  if ( !pDataSvc ) return StatusCode::SUCCESS; //Atlas does not use DataSvc
  if ( m_dataSvc ) m_dataSvc->release();
  m_dataSvc = pDataSvc;
  m_dataSvc->addRef();
  Workers::iterator stop  = m_workers->end();
  Workers::iterator start = m_workers->begin();
  for(Workers::iterator i=start; i != stop; i++ )    {
    IConverter* cnv = (*i).converter();
    if ( 0 != cnv )   {
      if (cnv->setDataProvider(m_dataSvc).isFailure()) {
        MsgStream log(msgSvc(), name());
        log << MSG::ERROR << "setting Data Provider" << endmsg;
      }
    }
  }
  return StatusCode::SUCCESS;
}

SmartIF<IDataProviderSvc>& ConversionSvc::dataProvider()  const   {
  return m_dataSvc;
}

StatusCode ConversionSvc::setAddressCreator(IAddressCreator* creator)   {
  m_addressCreator = creator;
  Workers::iterator stop  = m_workers->end();
  Workers::iterator start = m_workers->begin();
  for(Workers::iterator i=start; i != stop; i++ )    {
    IConverter* cnv = (*i).converter();
    if ( 0 != cnv )   {
      if (cnv->setAddressCreator(m_addressCreator).isFailure()) {
    MsgStream log(msgSvc(), name());
    log << MSG::ERROR << "setting Address Creator"  << endmsg;
      }
    }
  }
  return StatusCode::SUCCESS;
}

SmartIF<IAddressCreator>& ConversionSvc::addressCreator()  const   {
  return m_addressCreator;
}

StatusCode ConversionSvc::setConversionSvc(IConversionSvc* /* svc */)   {
  return StatusCode::FAILURE;
}

SmartIF<IConversionSvc>& ConversionSvc::conversionSvc()    const   {
  return m_cnvSvc;
}

StatusCode ConversionSvc::addConverter(const CLID& clid)  {
  // First look for the more specific converter
  long typ = repSvcType();
  IConverter* pConverter = createConverter(typ, clid, 0);
  if ( 0 != pConverter )    {
    StatusCode status = configureConverter( typ, clid, pConverter );
    if ( status.isSuccess() )   {
      status = initializeConverter( typ, clid, pConverter );
      if ( status.isSuccess() )   {
        status = activateConverter( typ, clid, pConverter );
        if ( status.isSuccess() )   {
          long conv_typ  = pConverter->repSvcType();
          const CLID&   conv_clid = pConverter->objType();
          typ      = (typ<0xFF) ? typ : typ&0xFFFFFF00;
          conv_typ = (conv_typ<0xFF) ? conv_typ : conv_typ&0xFFFFFF00;
          if ( conv_typ == typ && conv_clid == clid )   {
            return addConverter(pConverter);
          }
        }
      }
    }
    pConverter->release();
  }
  return NO_CONVERTER;
}

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

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()->finalize().ignore();
      (*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::initialize()     {
  StatusCode status = Service::initialize();
  return status;
}

StatusCode ConversionSvc::finalize()      {
  // Release all workers.
  MsgStream log(msgSvc(), name());
  for ( Workers::iterator i = m_workers->begin(); i != m_workers->end(); i++ )    {
    if ( (*i).converter()->finalize().isFailure() ) {
      log << MSG::ERROR << "finalizing worker" << endmsg;
    }
    (*i).converter()->release();
  }
  m_workers->erase(m_workers->begin(), m_workers->end() );
  // release interfaces
  m_addressCreator = 0;
  m_dataSvc = 0;
  m_cnvSvc = 0;
  return Service::finalize();
}


IConverter* ConversionSvc::createConverter(long typ,
                                           const CLID& clid,
                                           const ICnvFactory* /*fac*/)   {
  IConverter* pConverter;
  pConverter = Converter::Factory::create(ConverterID(typ,clid), serviceLocator().get());
  if ( 0 == pConverter )  {
    typ = (typ<0xFF) ? typ : typ&0xFFFFFF00;
    pConverter = Converter::Factory::create(ConverterID(typ,clid), serviceLocator().get());
  }
  return pConverter;
}

StatusCode ConversionSvc::configureConverter(long /* typ */,
                                              const CLID& /* clid */,
                                              IConverter* pConverter)    {
  if ( 0 != pConverter )    {
    pConverter->setConversionSvc(this).ignore();
    pConverter->setAddressCreator(m_addressCreator).ignore();
    pConverter->setDataProvider(m_dataSvc).ignore();
    return StatusCode::SUCCESS;
  }
  return NO_CONVERTER;
}

StatusCode ConversionSvc::initializeConverter(long /* typ */,
                                              const CLID& /* clid */,
                                              IConverter* pConverter)    {
  if ( pConverter )    {
    return pConverter->initialize();
  }
  return NO_CONVERTER;
}

StatusCode ConversionSvc::activateConverter(long /* typ */,
                                            const CLID& /* clid */,
                                            IConverter* pConverter)    {
  if ( 0 != pConverter )    {
    return StatusCode::SUCCESS;
  }
  return NO_CONVERTER;
}

const CLID& ConversionSvc::objType() const    {
  return CLID_NULL;
}

long ConversionSvc::repSvcType() const {
  return m_type;
}

StatusCode ConversionSvc::connectOutput(const std::string&    outputFile,
                                        const std::string& /* openMode */) {
  return connectOutput(outputFile);
}

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

StatusCode ConversionSvc::commitOutput(const std::string& , bool ) {
  return StatusCode::SUCCESS;
}

StatusCode ConversionSvc::createAddress(long                 /* svc_type */,
                                        const CLID&          /* clid     */,
                                        const std::string*   /* par      */,
                                        const unsigned long* /* ip       */,
                                        IOpaqueAddress*& refpAddress)    {
  refpAddress = 0;
  return StatusCode::FAILURE;
}

StatusCode ConversionSvc::convertAddress( const IOpaqueAddress* /* pAddress */,
                                          std::string& refAddress)
{
  refAddress = "";
  return StatusCode::FAILURE;
}

StatusCode ConversionSvc::createAddress( long /* svc_type */,
                                        const CLID& /* clid */,
                                        const std::string& /* refAddress */,
                                        IOpaqueAddress*& refpAddress)
{
  refpAddress = 0;
  return StatusCode::FAILURE;
}

ConversionSvc::ConversionSvc(const std::string& name, ISvcLocator* svc, long type)
 : base_class(name, svc),
   m_cnvSvc(static_cast<IConversionSvc*>(this))
{
  m_type            = type;
  m_dataSvc         = 0;
  m_workers = new Workers();
  setAddressCreator(this).ignore();
}

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;
}