DataSvcFileEntriesTool.cpp

Go to the documentation of this file.

// ========== header
#include "GaudiKernel/AlgTool.h"
#include "GaudiKernel/IDataStoreLeaves.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/SmartIF.h"

class IIncidentSvc;
class IDataManagerSvc;
class IDataProviderSvc;
class IRegistry;
class DataSvcFileEntriesTool: public extends2<AlgTool, IDataStoreLeaves, IIncidentListener> {
public:
  DataSvcFileEntriesTool(const std::string& type,
      const std::string& name,
      const IInterface* parent);

  virtual ~DataSvcFileEntriesTool();

  virtual StatusCode initialize();

  virtual StatusCode finalize();

  virtual const LeavesList & leaves() const;

  virtual void handle(const Incident& incident);

private:

  std::string m_dataSvcName;
  std::string m_rootNode;
  bool m_scanOnBeginEvent;

  SmartIF<IIncidentSvc> m_incidentSvc;
  SmartIF<IDataManagerSvc> m_dataMgrSvc;
  SmartIF<IDataProviderSvc> m_dataSvc;

  LeavesList m_leaves;

  void i_collectLeaves();
  void i_collectLeaves(IRegistry *reg);
};

// ========== implementation
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/DataStoreItem.h"

#include "GaudiKernel/GaudiException.h"

DataSvcFileEntriesTool::DataSvcFileEntriesTool(const std::string& type,
      const std::string& name,
      const IInterface* parent):
   base_class(type, name, parent) {

  declareProperty("DataService", m_dataSvcName = "EventDataSvc",
      "Name of the data service to use");

  declareProperty("Root", m_rootNode,
      "Path to the element from which to start the scan");

  declareProperty("ScanOnBeginEvent", m_scanOnBeginEvent = false,
      "If the scan has to be started during the BeginEvent incident (true) or on demand (false, default)");
}

DataSvcFileEntriesTool::~DataSvcFileEntriesTool() {}

StatusCode DataSvcFileEntriesTool::initialize(){
  StatusCode sc = AlgTool::initialize();
  if (sc.isFailure()) return sc;

  // Retrieve the pointer to the needed services.

  m_incidentSvc = serviceLocator()->service("IncidentSvc");
  if ( ! m_incidentSvc ) {
    MsgStream log(msgSvc(), name());
    log << MSG::ERROR << "Cannot get IncidentSvc" << endmsg;
    return StatusCode::FAILURE;
  }

  m_dataMgrSvc = m_dataSvc = serviceLocator()->service(m_dataSvcName);
  if ( ! m_dataSvc || ! m_dataMgrSvc ) {
    MsgStream log(msgSvc(), name());
    log << MSG::ERROR << "Cannot get IDataProviderSvc+IDataManagerSvc " << m_dataSvcName << endmsg;
    return StatusCode::FAILURE;
  }

  // Register ourself to the incident service as listener for BeginEvent
  m_incidentSvc->addListener(this, IncidentType::BeginEvent);

  // If the Root node is not specified, take the name from the data service itself.
  if (m_rootNode.empty()) {
    m_rootNode = m_dataMgrSvc->rootName();
  }

  // Clear the cache (in case the instance is re-initilized).
  m_leaves.clear();
  return StatusCode::SUCCESS;
}

StatusCode DataSvcFileEntriesTool::finalize(){
  // unregister from the incident service
  if (m_incidentSvc) {
    m_incidentSvc->removeListener(this, IncidentType::BeginEvent);
  }
  // Release the services
  m_incidentSvc.reset();
  m_dataMgrSvc.reset();
  m_dataSvc.reset();

  return AlgTool::finalize();
}

void DataSvcFileEntriesTool::handle(const Incident& incident) {
  m_leaves.clear();
  if (m_scanOnBeginEvent) {
    MsgStream log(msgSvc(), name());
    log << MSG::VERBOSE << "::handle scanning on " << incident.type() << endmsg;
    i_collectLeaves();
  }
}

const IDataStoreLeaves::LeavesList & DataSvcFileEntriesTool::leaves() const {
  if (m_leaves.empty()) {
    const_cast<DataSvcFileEntriesTool*>(this)->i_collectLeaves();
  }
  return m_leaves;
}

void DataSvcFileEntriesTool::i_collectLeaves() {
  DataObject * obj = 0;
  StatusCode sc = m_dataSvc->retrieveObject(m_rootNode, obj);
  if (sc.isSuccess()) {
    MsgStream log(msgSvc(), name());
    log << MSG::DEBUG << "::i_collectLeaves scanning " << m_dataSvcName
        << " from " << m_rootNode << endmsg;
    i_collectLeaves(obj->registry());
  } else {
    throw GaudiException("Cannot get " + m_rootNode + " from " + m_dataSvcName, name(), StatusCode::FAILURE);
  }
}

void DataSvcFileEntriesTool::i_collectLeaves(IRegistry* reg) {
  MsgStream log(msgSvc(), name());
  // I do not put sanity checks on the pointers because I know how I'm calling the function
  IOpaqueAddress *addr = reg->address();
  if (addr) { // we consider only objects that are in a file
    if (outputLevel() <= MSG::VERBOSE)
      log << MSG::VERBOSE << "::i_collectLeaves added " << reg->identifier() << endmsg;
    m_leaves.push_back(reg->object()); // add this object
    // Origin of the current object
    const std::string& base = addr->par()[0];

    std::vector<IRegistry*> lfs; // leaves of the current object
    StatusCode sc = m_dataMgrSvc->objectLeaves(reg, lfs);
    if (sc.isSuccess()) {
      for(std::vector<IRegistry*>::iterator i = lfs.begin(); i != lfs.end(); ++i)  {
        // Continue if the leaf has the same database as the parent
        if ( (*i)->address() && (*i)->address()->par()[0] == base )  {
          DataObject* obj = 0;
          sc = m_dataSvc->retrieveObject(reg, (*i)->name(), obj);
          if (sc.isSuccess())  {
            i_collectLeaves(*i);
          } else {
            throw GaudiException("Cannot get " + (*i)->identifier() + " from " + m_dataSvcName, name(), StatusCode::FAILURE);
          }
        }
      }
    }
  }
}


#include "GaudiKernel/ToolFactory.h"
DECLARE_TOOL_FACTORY(DataSvcFileEntriesTool)