TsDataSvc.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_TSDATASVC_H
#define GAUDIKERNEL_TSDATASVC_H

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

// External libraries
#include "tbb/recursive_mutex.h"
#include "tbb/spin_mutex.h"

namespace {
  typedef tbb::recursive_mutex tsDataSvcMutex;
  // typedef  tbb::spin_mutex tsDataSvcMutex;
} // namespace

// 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;
  // Generic registry entry
  class RegistryEntry;
} // namespace DataSvcHelpers

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

  IConversionSvc* m_dataLoader = nullptr;
  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"};
  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;
  std::unique_ptr<DataSvcHelpers::RegistryEntry> m_root;

public:
  CLID rootCLID() const override;

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

  StatusCode registerAddress( std::string_view fullPath, IOpaqueAddress* pAddress ) override;

  using IDataManagerSvc::registerAddress;

  StatusCode registerAddress( IRegistry* parentObj, std::string_view objectPath, IOpaqueAddress* pAddress ) override;

  using IDataManagerSvc::unregisterAddress;
  StatusCode unregisterAddress( std::string_view fullPath ) override;

  StatusCode unregisterAddress( IRegistry* pParent, std::string_view 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( std::string_view sub_tree_path ) override;

  StatusCode clearSubTree( DataObject* pObject ) override;

  StatusCode clearStore() override;

  StatusCode traverseSubTree( std::string_view 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         i_setRoot( DataObject* pRootObj ) { return i_setRoot( m_rootName, pRootObj ); }

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

  virtual StatusCode i_setRoot( std::string root_path, IOpaqueAddress* pRootAddr );
  StatusCode         i_setRoot( IOpaqueAddress* pRootAddr ) { return i_setRoot( m_rootName, 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( std::string_view parentPath, std::string_view objPath, DataObject* pObject ) override;

  StatusCode registerObject( DataObject* parentObj, std::string_view objPath, DataObject* pObject ) override;

  StatusCode unregisterObject( std::string_view fullPath ) override;

  StatusCode unregisterObject( DataObject* pObject ) override;

  StatusCode unregisterObject( DataObject* pObject, std::string_view objectPath ) override;

  using IDataProviderSvc::retrieveObject;

  StatusCode retrieveObject( IRegistry* pDirectory, std::string_view path, DataObject*& pObject ) override;

  using IDataProviderSvc::findObject;

  StatusCode findObject( std::string_view fullPath, DataObject*& pObject ) override;

  StatusCode findObject( IRegistry* pDirectory, std::string_view path, DataObject*& pObject ) override;

  using IDataProviderSvc::linkObject;

  StatusCode linkObject( IRegistry* from, std::string_view objPath, DataObject* to ) override;

  StatusCode linkObject( std::string_view fullPath, DataObject* to ) override;

  using IDataProviderSvc::unlinkObject;

  StatusCode unlinkObject( IRegistry* from, std::string_view objPath ) override;

  StatusCode unlinkObject( DataObject* fromObj, std::string_view objPath ) override;

  StatusCode unlinkObject( std::string_view fullPath ) override;

  StatusCode updateObject( IRegistry* pDirectory ) override;

  StatusCode updateObject( DataObject* toUpdate ) override;

  StatusCode initialize() override;

  StatusCode reinitialize() override;

  StatusCode finalize() override;

  using extends::extends;

  TsDataSvc( const TsDataSvc& ) = delete;
  TsDataSvc& operator=( const TsDataSvc& ) = 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, std::string_view path,
                            DataSvcHelpers::RegistryEntry*& pEntry );
  DataObject* handleDataFault( IRegistry* pReg, std::string_view path = {} );

  tsDataSvcMutex m_accessMutex;
};
#endif // GAUDIKERNEL_TSDATASVC_H