TsDataSvc.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 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.                                             *
\***********************************************************************************/
#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"
 
// System libraries
#include <mutex>
 
namespace {
  typedef std::recursive_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