RecordDataSvc.cpp

Go to the documentation of this file.

//====================================================================
//  RecordDataSvc.cpp
//--------------------------------------------------------------------
//
//  Package    : System ( The LHCb Offline System)
//
//  Description: implementation of the Transient event data service.
//
//  Author     : M.Frank
//  History    :
// +---------+----------------------------------------------+---------
// |    Date |                 Comment                      | Who
// +---------+----------------------------------------------+---------
// | 10/12/08| Initial version                              | MF
// +---------+----------------------------------------------+---------
//
//====================================================================
#define DATASVC_RECORDDATASVC_CPP

#include "GaudiKernel/DataIncident.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/IProperty.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/RegistryEntry.h"
#include "GaudiKernel/SmartIF.h"

#include "RecordDataSvc.h"
using namespace std;

// Instantiation of a static factory class used by clients to create
// instances of this service
DECLARE_COMPONENT( RecordDataSvc )

StatusCode RecordDataSvc::initialize()
{
  // Nothing to do: just call base class initialisation
  StatusCode sc = DataSvc::initialize();

  if ( !sc.isSuccess() ) { // Base class failure
    return sc;
  }
  // Attach data loader facility
  m_cnvSvc = service( m_persSvcName, true );
  if ( !m_cnvSvc ) {
    error() << "Failed to access RecordPersistencySvc." << endmsg;
    return StatusCode::FAILURE;
  }
  auto prp = m_cnvSvc.as<IProperty>();
  if ( prp ) {
    // prp->setProperty();
  }
  sc = setDataLoader( m_cnvSvc.get() );
  if ( !sc.isSuccess() ) {
    error() << "Failed to attach dataloader RecordPersistencySvc." << endmsg;
    return sc;
  }

  sc = setRoot( m_rootName, new DataObject() );
  if ( !sc.isSuccess() ) {
    warning() << "Error declaring Record root DataObject" << endmsg;
    return sc;
  }

  if ( !m_incidentSvc ) {
    fatal() << "IncidentSvc is invalid--base class failed." << endmsg;
    return sc;
  }

  m_incidentSvc->addListener( this, "FILE_OPEN_READ" );
  m_incidentSvc->addListener( this, m_saveIncidentName );
  return sc;
}

StatusCode RecordDataSvc::finalize()
{
  if ( m_incidentSvc ) m_incidentSvc->removeListener( this );
  m_cnvSvc.reset();
  DataSvc::finalize().ignore();
  return StatusCode::SUCCESS;
}

void RecordDataSvc::handle( const Incident& incident )
{
  if ( incident.type() == "FILE_OPEN_READ" ) {
    typedef ContextIncident<IOpaqueAddress*> Ctxt;
    auto inc = dynamic_cast<const Ctxt*>( &incident );
    if ( !inc ) {
      always() << "Received invalid incident of type:" << incident.type() << endmsg;
    } else {
      registerRecord( inc->source(), inc->tag() );
      if ( !m_incidentName.empty() ) {
        auto incidents = m_incidents;
        m_incidents.clear();
        for ( const auto& i : incidents ) m_incidentSvc->fireIncident( Incident{i, m_incidentName} );
      }
    }
  } else if ( incident.type() == m_saveIncidentName ) {
    always() << "Saving records not implemented." << endmsg;
  }
}

void RecordDataSvc::loadRecords( IRegistry* pObj )
{
  if ( !pObj ) {
    error() << "Failed to load records object: " << pObj->identifier() << endmsg;
  } else {
    vector<IRegistry*> leaves;
    DataObject* p     = nullptr;
    const string& id0 = pObj->identifier();
    StatusCode sc     = retrieveObject( id0, p );
    if ( sc.isSuccess() ) {
      debug() << "Loaded records object: " << id0 << endmsg;
      sc = objectLeaves( pObj, leaves );
      if ( sc.isSuccess() ) {
        for ( const auto& i : leaves ) loadRecords( i );
      }
    }
  }
}

void RecordDataSvc::registerRecord( const string& data, IOpaqueAddress* pAddr )
{
  if ( !data.empty() && pAddr ) {
    string fid = data;
    debug() << "Request to load record for file " << fid << endmsg;
    StatusCode sc = registerAddress( m_root, fid, pAddr );
    if ( !sc.isSuccess() ) {
      warning() << "Failed to register record for:" << fid << endmsg;
      pAddr->release();
      return;
    }
    if ( m_autoLoad ) {
      loadRecords( pAddr->registry() );
    }
    m_incidents.push_back( pAddr->registry()->identifier() );
  } else if ( !data.empty() && !pAddr ) {
    info() << "Failed to register record for:" << data << " [Invalid Address]" << endmsg;
  }
}

RecordDataSvc::RecordDataSvc( const string& name, ISvcLocator* svc ) : base_class( name, svc )
{
  m_rootName = "/Records";
}