TsDataSvc.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/DataStoreItem.h>
#include <GaudiKernel/IDataManagerSvc.h>
#include <GaudiKernel/IDataProviderSvc.h>
#include <GaudiKernel/IIncidentSvc.h>
#include <GaudiKernel/RegistryEntry.h>
#include <GaudiKernel/Service.h>
#include <GaudiKernel/ServiceHandle.h>
#include <mutex>
 
namespace {
  typedef std::recursive_mutex tsDataSvcMutex;
} // namespace
class IOpaqueAddress;
class DataObject;
class IDataStoreAgent;
 
namespace DataSvcHelpers {
  class InhibitMap;
  class RegistryEntry;
} // namespace DataSvcHelpers

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

  IConversionSvc* m_dataLoader = nullptr;
  ServiceHandle<IIncidentSvc> m_incidentSvc;
 
  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, "InhibitPaths", {}, "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;

  TsDataSvc( const std::string& name, ISvcLocator* svc );

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