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 extends<AlgTool,
                                             IDataStoreLeaves,
                                             IIncidentListener> {
public:
  DataSvcFileEntriesTool(const std::string& type,
      const std::string& name,
      const IInterface* parent);

  ~DataSvcFileEntriesTool() override = default;

  StatusCode initialize() override;

  StatusCode finalize() override;

  const LeavesList & leaves() const override;

  void handle(const Incident& incident) override;

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

  IRegistry* i_getRootNode();

  std::string m_initialBase;

  bool m_ignoreOriginChange;
};

// ========== 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)");

  declareProperty("IgnoreOriginChange", m_ignoreOriginChange = false,
      "Disable the detection of the change in the origin of object between the BeginEvent and the scan");
}

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 ) {
    error() << "Cannot get IncidentSvc" << endmsg;
    return StatusCode::FAILURE;
  }

  m_dataMgrSvc = m_dataSvc = serviceLocator()->service(m_dataSvcName);
  if ( ! m_dataSvc || ! m_dataMgrSvc ) {
    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) {
  // Get the file id of the root node at every event
  IOpaqueAddress *addr = i_getRootNode()->address();
  if (addr)
    m_initialBase = addr->par()[0];
  else
    m_initialBase.clear(); // use empty file id if there is no address

  m_leaves.clear();
  if (m_scanOnBeginEvent) {
    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;
}

IRegistry* DataSvcFileEntriesTool::i_getRootNode() {
  DataObject * obj = nullptr;
  StatusCode sc = m_dataSvc->retrieveObject(m_rootNode, obj);
  if (sc.isFailure()) {
    throw GaudiException("Cannot get " + m_rootNode + " from " + m_dataSvcName, name(), StatusCode::FAILURE);
  }
  return obj->registry();
}


void DataSvcFileEntriesTool::i_collectLeaves() {
  i_collectLeaves(i_getRootNode());
}

void DataSvcFileEntriesTool::i_collectLeaves(IRegistry* reg) {
  // 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 (msgLevel(MSG::VERBOSE))
      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];
    // Compare with the origin seen during BeginEvent
    if ( !m_ignoreOriginChange && (m_initialBase != base) )
      throw GaudiException("Origin of data has changed ('"
                           + m_initialBase + "' !=  '" + base
                           + "'), probably OutputStream was called before "
                               "InputCopyStream: check options",
                           name(), StatusCode::FAILURE);

    std::vector<IRegistry*> lfs; // leaves of the current object
    StatusCode sc = m_dataMgrSvc->objectLeaves(reg, lfs);
    if (sc.isSuccess()) {
      for(const auto& i : lfs) {
        // Continue if the leaf has the same database as the parent
        if ( i->address() && i->address()->par()[0] == base )  {
          DataObject* obj = nullptr;
          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);
          }
        }
      }
    }
  }
}


DECLARE_COMPONENT(DataSvcFileEntriesTool)