Converter.cpp

Go to the documentation of this file.

// Include Files
#include "GaudiKernel/Converter.h"
#include "GaudiKernel/INamedInterface.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/ServiceLocatorHelper.h"
#include "GaudiKernel/ThreadGaudi.h"
#include "GaudiKernel/ConversionSvc.h"

const CLID& Converter::objType() const    {
  return m_classType;
}

long Converter::i_repSvcType() const   {
  return m_storageType;
}

StatusCode Converter::createObj(IOpaqueAddress*, DataObject*&)   {
  return StatusCode::SUCCESS;
}


StatusCode Converter::fillObjRefs(IOpaqueAddress*, DataObject*)    {
  return StatusCode::SUCCESS;
}

StatusCode Converter::updateObj(IOpaqueAddress*, DataObject*)   {
  return StatusCode::SUCCESS;
}

StatusCode Converter::updateObjRefs(IOpaqueAddress*, DataObject*)  {
  return StatusCode::SUCCESS;
}

StatusCode Converter::createRep(DataObject*, IOpaqueAddress*&)  {
  return StatusCode::SUCCESS;
}

StatusCode Converter::fillRepRefs(IOpaqueAddress*, DataObject*)  {
  return StatusCode::SUCCESS;
}

StatusCode Converter::updateRep(IOpaqueAddress*, DataObject*)  {
  return StatusCode::SUCCESS;
}

StatusCode Converter::updateRepRefs(IOpaqueAddress*, DataObject*)    {
  return StatusCode::SUCCESS;
}

StatusCode Converter::initialize()    {
  // Get a reference to the Message Service
  if ( !msgSvc() )   {
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

StatusCode Converter::finalize() {
  // release services
  m_messageSvc = nullptr;
  m_dataManager = nullptr;
  m_dataProvider = nullptr;
  m_conversionSvc = nullptr;
  m_addressCreator = nullptr;
  return StatusCode::SUCCESS;
}

StatusCode Converter::setDataProvider(IDataProviderSvc* svc) {
  m_dataProvider = svc;
  m_dataManager = svc;
  return StatusCode::SUCCESS;
}

SmartIF<IDataProviderSvc>& Converter::dataProvider()  const    {
  return m_dataProvider;
}

SmartIF<IDataManagerSvc>& Converter::dataManager()  const    {
  return m_dataManager;
}

StatusCode Converter::setConversionSvc(IConversionSvc* svc)   {
  m_conversionSvc = svc;
  return StatusCode::SUCCESS;
}

SmartIF<IConversionSvc>& Converter::conversionSvc()  const    {
  return m_conversionSvc;
}

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

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

SmartIF<ISvcLocator>& Converter::serviceLocator()  const     {
  return m_svcLocator;
}

SmartIF<IMessageSvc>& Converter::msgSvc()  const   {
  if ( !m_messageSvc ) {
    m_messageSvc = serviceLocator();
    if( !m_messageSvc ) {
      throw GaudiException("Service [MessageSvc] not found", "Converter", StatusCode::FAILURE);
    }
  }
  return m_messageSvc;
}

// Obsoleted name, kept due to the backwards compatibility
SmartIF<IMessageSvc>& Converter::messageService()  const   {
  return msgSvc();
}

Converter::Converter(long storage_type, const CLID& class_type, ISvcLocator* svc) :
  m_storageType(storage_type),
  m_classType(class_type),
  m_svcLocator(svc)
{
}

StatusCode
Converter::service_i(const std::string& svcName, bool createIf,
             const InterfaceID& iid, void** ppSvc) const {
  // Check for name of conversion service
  SmartIF<INamedInterface> cnvsvc(conversionSvc());
  if (cnvsvc) {
    const ServiceLocatorHelper helper(*serviceLocator(), "Converter", cnvsvc->name());
    return helper.getService(svcName, createIf, iid, ppSvc);
  }
  return StatusCode::FAILURE;
}

StatusCode
Converter::service_i(const std::string& svcType, const std::string& svcName,
             const InterfaceID& iid, void** ppSvc) const {
  // Check for name of conversion service
  SmartIF<INamedInterface> cnvsvc(conversionSvc());
  if (cnvsvc) {
    const ServiceLocatorHelper helper(*serviceLocator(), "Converter", cnvsvc->name());
    return helper.createService(svcType, svcName, iid, ppSvc);
  }
  return StatusCode::FAILURE;
}

SmartIF<IService> Converter::service(const std::string& name, const bool createIf) const {
  SmartIF<INamedInterface> cnvsvc(conversionSvc());
  SmartIF<IService> svc;
  if (cnvsvc) {
    const ServiceLocatorHelper helper(*serviceLocator(), "Converter", cnvsvc->name());
    svc = helper.service(name, false, createIf);
  }
  return svc;
}