DataSvc.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_DATASVC_H
#define GAUDIKERNEL_DATASVC_H

// Include files
#include "GaudiKernel/DataStoreItem.h"
#include "GaudiKernel/IConversionSvc.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/RegistryEntry.h"
#include "GaudiKernel/Service.h"
#include "GaudiKernel/SmartIF.h"

#include <boost/utility/string_ref.hpp>

// Forward declarations
// Incident service
class IIncidentSvc;
// Generic address
class IOpaqueAddress;
// Generic interface to data object class
class DataObject;
// Data store agent
class IDataStoreAgent;

// Do not clutter global namespace for helpers...
namespace DataSvcHelpers
{
  // Map of objects where loading is inhibited
  class InhibitMap;
}

class GAUDI_API DataSvc : public extends<Service, IDataProviderSvc, IDataManagerSvc>
{

  SmartIF<IConversionSvc> m_dataLoader = nullptr;

protected:
  SmartIF<IIncidentSvc> m_incidentSvc = nullptr;

  Gaudi::Property<CLID>        m_rootCLID{this, "RootCLID", 110 /*CLID_Event*/, "CLID of root entry"};
  Gaudi::Property<std::string> m_rootName{this, "RootName", "/Event", "name of root entry"};

private:
  Gaudi::Property<bool> m_forceLeaves{this, "ForceLeaves", false, "force creation of default leaves on registerObject"};
  Gaudi::Property<std::vector<std::string>> m_inhibitPathes{this, "InhibitPathes", {}, "inhibited leaves"};

  Gaudi::Property<bool> m_enableFaultHdlr{this, "EnableFaultHandler", false,
                                          "enable incidents on data creation requests"};
  Gaudi::Property<std::string> m_faultName{this, "DataFaultName", "DataFault", "Name of the data fault incident"};

  Gaudi::Property<bool> m_enableAccessHdlr{this, "EnableAccessHandler", false,
                                           "enable incidents on data access requests"};
  Gaudi::Property<std::string> m_accessName{this, "DataAccessName", "DataAccess", "Name of the data access incident"};

  std::vector<DataStoreItem> m_preLoads;

protected:
  std::unique_ptr<DataSvcHelpers::RegistryEntry> m_root;

private:
  DataSvcHelpers::InhibitMap* m_inhibitMap = nullptr;

public:
  CLID rootCLID() const override;

  const std::string& rootName() const override;

  StatusCode registerAddress( boost::string_ref fullPath, IOpaqueAddress* pAddress ) override;

  using IDataManagerSvc::registerAddress;

  StatusCode registerAddress( IRegistry* parentObj, boost::string_ref objectPath, IOpaqueAddress* pAddress ) override;

  using IDataManagerSvc::unregisterAddress;

  StatusCode unregisterAddress( boost::string_ref fullPath ) override;

  StatusCode unregisterAddress( IRegistry* pParent, boost::string_ref objPath ) override;

  StatusCode objectLeaves( const DataObject* pObject, std::vector<IRegistry*>& refLeaves ) override;
  StatusCode objectLeaves( const IRegistry* pRegistry, std::vector<IRegistry*>& refLeaves ) override;

  StatusCode objectParent( const DataObject* pObject, IRegistry*& refpParent ) override;
  StatusCode objectParent( const IRegistry* pRegistry, IRegistry*& refpParent ) override;

  StatusCode clearSubTree( boost::string_ref sub_tree_path ) override;

  StatusCode clearSubTree( DataObject* pObject ) override;

  StatusCode clearStore() override;

  StatusCode traverseSubTree( boost::string_ref sub_tree_path, IDataStoreAgent* pAgent ) override;

  StatusCode traverseSubTree( DataObject* pObject, IDataStoreAgent* pAgent ) override;

  StatusCode traverseTree( IDataStoreAgent* pAgent ) override;

  StatusCode setRoot( std::string root_name, DataObject* pRootObj ) override;

  virtual StatusCode i_setRoot( std::string root_name, DataObject* pRootObj );

  StatusCode setRoot( std::string root_path, IOpaqueAddress* pRootAddr ) override;

  virtual StatusCode i_setRoot( std::string root_path, IOpaqueAddress* pRootAddr );

  StatusCode setDataLoader( IConversionSvc* svc, IDataProviderSvc* dpsvc = nullptr ) override;

  StatusCode addPreLoadItem( const DataStoreItem& item ) override;

  StatusCode removePreLoadItem( const DataStoreItem& item ) override;

  StatusCode resetPreLoad() override;

  virtual StatusCode preLoad( int depth, int load_depth, DataObject* pObject );

  StatusCode preLoad() override;

  using IDataProviderSvc::registerObject;

  StatusCode registerObject( boost::string_ref parentPath, boost::string_ref objPath, DataObject* pObject ) override;

  StatusCode registerObject( DataObject* parentObj, boost::string_ref objPath, DataObject* pObject ) override;

  StatusCode unregisterObject( boost::string_ref fullPath ) override;

  StatusCode unregisterObject( DataObject* pObject ) override;

  StatusCode unregisterObject( DataObject* pObject, boost::string_ref objectPath ) override;

  using IDataProviderSvc::retrieveObject;

  StatusCode retrieveObject( IRegistry* pDirectory, boost::string_ref path, DataObject*& pObject ) override;

  using IDataProviderSvc::findObject;

  StatusCode findObject( boost::string_ref fullPath, DataObject*& pObject ) override;

  StatusCode findObject( IRegistry* pDirectory, boost::string_ref path, DataObject*& pObject ) override;

  using IDataProviderSvc::linkObject;

  StatusCode linkObject( IRegistry* from, boost::string_ref objPath, DataObject* to ) override;

  StatusCode linkObject( boost::string_ref fullPath, DataObject* to ) override;

  using IDataProviderSvc::unlinkObject;

  StatusCode unlinkObject( IRegistry* from, boost::string_ref objPath ) override;

  StatusCode unlinkObject( DataObject* fromObj, boost::string_ref objPath ) override;

  StatusCode unlinkObject( boost::string_ref fullPath ) override;

  StatusCode updateObject( IRegistry* pDirectory ) override;

  StatusCode updateObject( DataObject* toUpdate ) override;

  StatusCode initialize() override;

  StatusCode reinitialize() override;

  StatusCode finalize() override;

  using extends::extends;

  DataSvc( const DataSvc& ) = delete;
  DataSvc& operator=( const DataSvc& ) = delete;

protected:
  bool checkRoot() { return 0 != m_root; }

  virtual IConversionSvc* getDataLoader( IRegistry* pReg );

  virtual DataObject* createDefaultObject() const;

  virtual StatusCode loadObject( IRegistry* pNode );

  virtual StatusCode loadObject( IConversionSvc* pLoader, IRegistry* pNode );

  StatusCode retrieveEntry( DataSvcHelpers::RegistryEntry* pNode, boost::string_ref path,
                            DataSvcHelpers::RegistryEntry*& pEntry );
  DataObject* handleDataFault( IRegistry* pReg, boost::string_ref path = "" );

private:
  StatusCode i_retrieveEntry( DataSvcHelpers::RegistryEntry* parentObj, boost::string_ref path,
                              DataSvcHelpers::RegistryEntry*& pEntry );
  DataObject* i_handleDataFault( IRegistry* pReg, boost::string_ref path = boost::string_ref{} );
};
#endif // GAUDIKERNEL_DATASVC_H