---

PersistencySvc.cpp

Go to the documentation of this file.

//====================================================================
//      PersistencySvc.cpp
//--------------------------------------------------------------------
//
//      Package    : System ( The LHCb Offline System)
//
//  Description: implementation of the PersistencySvc
//
//      Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who     
// +---------+----------------------------------------------+---------
// | 29/10/98| Initial version                              | MF
// +---------+----------------------------------------------+---------
//
//====================================================================
#define  PERSISTENCYSVC_PERSISTENCYSVC_CPP

// Interface defintions
#include "GaudiKernel/SmartIF.h"
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/CnvFactory.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/GenericLink.h"
#include "GaudiKernel/IConverter.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IDataSelector.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/MsgStream.h"

#ifdef WIN32
#  define strncasecmp _strnicmp
#else
#  include <strings.h>
#endif

// Implementation specific definitions
#include "PersistencySvc.h"

// Instantiation of a static factory class used by clients to create
// instances of this service
static const SvcFactory<PersistencySvc> s_factory;
const ISvcFactory& PersistencySvcFactory = s_factory;

StatusCode PersistencySvc::initialize()     {
  // Initialize basic service
  StatusCode status = Service::initialize();
  MsgStream log( msgSvc(), name() ); // Service MUST be initialized BEFORE!
  if ( status.isFailure() )   {
    log << MSG::ERROR << "Error initializing Service base class." << endreq;
    return status;
  }
  status = setProperties();
  if ( status.isFailure() )   {
    log << MSG::ERROR << "Error retrieving properties." << endreq;
    return status;
  }
  // Run through the service name list and attach the appropriate services
  status = decodeSvcNames( );
  return status;
}

StatusCode PersistencySvc::finalize()      {
  m_knownSvc.erase(m_knownSvc.begin(), m_knownSvc.end());
  for ( Services::iterator i = m_cnvServices.begin(); i != m_cnvServices.end(); i++ )    {
    (*i).second.service()->release();
  }
  return StatusCode::SUCCESS;
}

StatusCode PersistencySvc::createObj(IOpaqueAddress* pAddress, DataObject*& refpObject)   {
  unsigned char svc_type = pAddress->svcType();     // Get proper service type
  IConversionSvc* svc    = service(svc_type);       // Find corrponding data service
  StatusCode   status    = BAD_STORAGE_TYPE;        // Preset error
  if ( 0 != svc )   {
    status = svc->createObj(pAddress, refpObject);  // invoke service call
    return status;
  }
  refpObject = 0;                                   // Bad luck: service not availible
  // on fatal errors throw exception
  return status;
}

StatusCode PersistencySvc::updateObj(IOpaqueAddress* pAddress, DataObject* pObject)   {
  unsigned char svc_type = pAddress->svcType();     // Get proper service type
  IConversionSvc* svc    = service(svc_type);       // Find corrponding data service
  StatusCode   status    = BAD_STORAGE_TYPE;        // Preset error
  if ( 0 != svc )   {
    status = svc->updateObj(pAddress, pObject);     // invoke service call
    return status;
  }
  pObject = 0;                                      // Bad luck: service not availible
  // on fatal errors throw exception
  return status;
}

StatusCode PersistencySvc::updateReps(IDataSelector* pSelector)     {
  StatusCode status = SUCCESS, iret = SUCCESS;
  // For updating representation it is not necessary to keep the
  // two/three steps: The presentations are already present 
  // in the persistent storage.
  for ( Services::iterator i = m_cnvServices.begin(); i != m_cnvServices.end(); i++ )    {
    // Each service must pick out his part to be updated....
    iret = (*i).second.service()->updateReps(pSelector);
    if ( iret.isSuccess() )      {
      status = iret;
    }
  }
  return iret;
}

StatusCode PersistencySvc::createReps(IDataSelector* pSelector)   {
  StatusCode status = NO_CONVERTER;
  // Simply pass the seelction to the default output stream service
  if ( 0 != m_cnvDefault )   {
    status = m_cnvDefault->createReps(pSelector);
  }
  return status;
}

IConversionSvc* PersistencySvc::service(unsigned char type)     {
  Services::iterator it = m_cnvServices.find( type );
  if( it != m_cnvServices.end() ) {
    return (*it).second.service();
  }
  for ( std::vector<IConversionSvc*>::iterator ik=m_knownSvc.begin(); ik != m_knownSvc.end(); ik++ )   {
    IConversionSvc* cnvSvc = (*ik);
    unsigned char svcTyp = cnvSvc->repSvcType();
    if ( type == svcTyp )    {
      StatusCode iret = addCnvService( cnvSvc );
      if ( !iret.isSuccess() )   {
        MsgStream log( msgSvc(), name() );
        SmartIF<IService> sif(IID_IService, cnvSvc);
        if ( sif.isValid( ) )  {
          log << MSG::ERROR << "Cannot use Conversion service:" << sif->name() << endreq;
        }
        else  {
          log << MSG::ERROR << "Cannot use Conversion service: Bad interface" << endreq;
        }
      }
      else    {
        m_knownSvc.erase(ik);
        return cnvSvc;
      }
    }
  }
  return 0;
}

IAddressCreator* PersistencySvc::addressCreator(unsigned char type)     {
  Services::iterator it = m_cnvServices.find( type );
  if( it == m_cnvServices.end() ) {
    IConversionSvc* s = service(type);
    if ( s )   {
      it = m_cnvServices.find( type );
      if ( it != m_cnvServices.end() ) {
        return (*it).second.addrCreator();
      }
    }
    return 0;
  }
  return (*it).second.addrCreator();
}

StatusCode PersistencySvc::setStore(IDataProviderSvc* pDataSvc)    {
  m_dataSvc = pDataSvc;
  for ( Services::iterator i = m_cnvServices.begin(); i != m_cnvServices.end(); i++ )   {
    (*i).second.service()->setStore(m_dataSvc);
  }
  return StatusCode::SUCCESS;
}

StatusCode PersistencySvc::addConverter(IConverter* pConverter)  {
  unsigned char   typ    = pConverter->repSvcType();
  IConversionSvc* svc    = service(typ);
  StatusCode      status = BAD_STORAGE_TYPE;
  if ( 0 != svc )   {
    status = svc->addConverter(pConverter);
  }
  return status;
}

StatusCode PersistencySvc::addConverter(const ICnvFactory& refFactory)  {
  StatusCode      status = NO_CONVERTER;
  IConverter* pConverter = refFactory.instantiate(serviceLocator());
  if ( 0 != pConverter )    {
    unsigned char   typ    = pConverter->repSvcType();
    IConversionSvc* svc    = service(typ);
    status = BAD_STORAGE_TYPE;
    if ( 0 != svc )   {
      status = svc->addConverter(pConverter);
    }
  }
  return status;
}

StatusCode PersistencySvc::removeConverter(const CLID& clid)  {
  // Remove converter type from all services
  StatusCode status = NO_CONVERTER, iret = StatusCode::SUCCESS;
  for ( Services::iterator i = m_cnvServices.begin(); i != m_cnvServices.end(); i++ )    {
    iret = (*i).second.service()->removeConverter(clid);
    if ( iret.isSuccess() )    {
      status = iret;
    }
  }
  return status;
}

StatusCode PersistencySvc::addCnvService(IConversionSvc* servc)    {
  if ( 0 != servc )   {
    IAddressCreator* icr = 0;
    StatusCode status  = servc->queryInterface(IID_IAddressCreator, (void**)&icr);
    unsigned char type = servc->repSvcType();
    if ( status.isSuccess() )   {
      Services::iterator it = m_cnvServices.find( type );
      IConversionSvc* cnv_svc = 0;
      if ( it != m_cnvServices.end() )    {
        cnv_svc = (*it).second.service();
      }
      if ( cnv_svc != servc )   {
        if ( 0 != cnv_svc )   {
          removeCnvService (type);
        }
        std::pair<Services::iterator, bool> p =
          m_cnvServices.insert( Services::value_type( type, ServiceEntry(type, servc, icr)));
        if( p.second == false)    {
          return StatusCode::FAILURE;
        }
        servc->addRef();
      }
      if ( type == m_cnvDefType )     {
        m_cnvDefault = servc;
      }
      servc->setAddressCreator(this);
      return StatusCode::SUCCESS;
    }
  }
  return BAD_STORAGE_TYPE;
}

StatusCode PersistencySvc::removeCnvService(unsigned char svctype)    {
  Services::iterator it = m_cnvServices.find( svctype );
  if( it != m_cnvServices.end() ) {
    (*it).second.service()->release();
    m_cnvServices.erase(it);
    return StatusCode::SUCCESS;
  }
  return BAD_STORAGE_TYPE;
}

unsigned char PersistencySvc::repSvcType() const {
  return m_cnvDefault->repSvcType();
}

StatusCode PersistencySvc::setDefaultCnvService(unsigned char type)     {
  m_cnvDefault = service(type);
  return StatusCode::SUCCESS;
}

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

StatusCode PersistencySvc::createAddress(const GenericLinkBase& link, 
                                        const std::string& dbName, 
                                        const std::string& contName, 
                                        const std::string& objName, 
                                        IOpaqueAddress*& refpAddress)    {
  IAddressCreator* svc = addressCreator(link.svcType());
  StatusCode   status  = BAD_STORAGE_TYPE;        // Preset error
  refpAddress = 0;
  if ( 0 != svc )   {
    status = svc->createAddress(link, dbName, contName, objName, refpAddress);
  }
  return status;
}

StatusCode PersistencySvc::createAddress(unsigned char type, 
                                         const CLID& classId,
                                         const std::string& dbName, 
                                         const std::string& contName, 
                                         int seqId,
                                         IOpaqueAddress*& refpAddress)    {
  IAddressCreator* svc = addressCreator(type);
  StatusCode   status  = BAD_STORAGE_TYPE;        // Preset error
  refpAddress = 0;
  if ( 0 != svc )   {
    status = svc->createAddress(type, classId, dbName, contName, seqId, refpAddress);
  }
  return status;
}

StatusCode PersistencySvc::setAddressCreator(IAddressCreator*)    {
  // The persistency service is a address creation dispatcher istelf.
  // The persistency service can NEVER create addresses itself.
  // The entry point must only be provided in order to fulfill the needs of the
  // implementing interfaces.
  return StatusCode::FAILURE;
}

StatusCode PersistencySvc::getService(unsigned char service_type, IConversionSvc*& refpSvc)     {
  refpSvc = service(service_type);
  return (0==refpSvc) ? StatusCode::FAILURE : StatusCode::SUCCESS;
}

StatusCode PersistencySvc::getService(const std::string& service_type, IConversionSvc*& refpSvc)     {
  const char* imp = service_type.c_str();
  long len = strlen(imp);
  if ( ::strncasecmp(imp,"SICB", len) == 0 )
    return getService(SICB_StorageType, refpSvc);
  else if ( ::strncasecmp(imp,"ZEBRA", len) == 0 )
    return getService(SICB_StorageType, refpSvc);
  else if ( ::strncasecmp(imp,"MS Access", len) == 0 )
    return getService(ACCESS_StorageType, refpSvc);
  else if ( ::strncasecmp(imp,"Microsoft Access", strlen("Microsoft Access")) == 0 )
    return getService(ACCESS_StorageType, refpSvc);
  else if ( ::strncasecmp(imp,"SQL Server", len) == 0 )
    return getService(SQLSERVER_StorageType, refpSvc);
  else if ( ::strncasecmp(imp,"Microsoft ODBC for Oracle", len) == 0 )
    return getService(ORACLE_StorageType, refpSvc);
  else if ( ::strncasecmp(imp,"Oracle ODBC", strlen("Oracle ODBC")) == 0 )
    return getService(ORACLE_StorageType, refpSvc);
  else if ( ::strncasecmp(imp,"Oracle OCI", strlen("Oracle OCI")) == 0 )
    return getService(ORACLE_StorageType, refpSvc);
  else if ( ::strncasecmp(imp,"MySQL", len) == 0 )
    return getService(MYSQL_StorageType, refpSvc);
  else if ( ::strncasecmp(imp,"ROOT", len) == 0 )
    return getService(ROOT_StorageType, refpSvc);
  else if ( ::strncasecmp(imp,"OBJY", len) == 0 )
    return getService(OBJY_StorageType, refpSvc);
  else if ( ::strncasecmp(imp,"OBJYECTI", 7) == 0 )
    return getService(OBJY_StorageType, refpSvc);
  return StatusCode::FAILURE;
}

StatusCode PersistencySvc::queryInterface(const IID& riid, void** ppvInterface)  {
  if ( IID_IConversionSvc == riid )  {
    *ppvInterface = (IConversionSvc*)this;
  }
  else if ( IID_IPersistencySvc == riid )  {
    *ppvInterface = (IPersistencySvc*)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;
}

StatusCode PersistencySvc::decodeSvcNames( )
{
  StatusCode result = StatusCode::SUCCESS;
  if ( state( ) == INITIALIZED ) {
    MsgStream log( msgSvc(), name() );
    const std::vector<std::string>& theNames = m_svcNames.value( );
    for ( std::vector<std::string>::const_iterator i = theNames.begin(); i != theNames.end(); i++ )   {
      IConversionSvc* svc = 0;
      StatusCode iret = serviceLocator()->getService(*i, IID_IConversionSvc,(IInterface*&)svc);
      if ( iret.isSuccess() )   {
        m_knownSvc.push_back(svc);
        log << MSG::INFO << "Added successfully Conversion service:" << *i << endreq;
      }
      else  {
        log << MSG::INFO << "Cannot add Conversion service:" << *i << " (Bad Interface)" << endreq;
      }
    }
  }
  return result;
}

void PersistencySvc::svcNamesHandler( Property& /* theProp */ )
{
    decodeSvcNames( );
}

PersistencySvc::PersistencySvc(const std::string& name, ISvcLocator* svc)
 :  Service(name, svc), 
    m_cnvDefType(TEST_StorageType), 
    m_dataSvc(0),
    m_cnvDefault(0)
{
        declareProperty("CnvServices", m_svcNames);
    m_svcNames.declareUpdateHandler( &PersistencySvc::svcNamesHandler, this );
}

PersistencySvc::~PersistencySvc()   {
  // Release all workers
  for ( Services::iterator i = m_cnvServices.begin(); i != m_cnvServices.end(); i++ )    {
    (*i).second.service()->release();
  }
  m_cnvServices.erase(m_cnvServices.begin(), m_cnvServices.end());
  m_knownSvc.erase(m_knownSvc.begin(), m_knownSvc.end());
}

---