MetaDataSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENASERVICES_METADATASVC_H
#define ATHENASERVICES_METADATASVC_H
 
#include <map>
#include <set>
#include <typeinfo>
 
#include "AthenaBaseComps/AthService.h"
#include "AthenaKernel/IAddressProvider.h"
#include "AthenaKernel/IAthMetaDataSvc.h"
#include "AthenaKernel/IMetaDataTool.h"
#include "Gaudi/Property.h"  // no forward decl: typedef
#include "GaudiKernel/IClassIDSvc.h"
#include "GaudiKernel/IFileMgr.h"  // for FILEMGR_CALLBACK_ARGS
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/IIoComponent.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/FileIncident.h"
 
// Forward declarations
class IAddressCreator;
class StoreGateSvc;
class IAlgTool;
class OutputStreamSequencerSvc;
 
namespace Io {
  class FileAttr;
}
 
static const InterfaceID IID_MetaDataSvc("MetaDataSvc", 1, 0);
 
// forward declaration to allow making SvcFactory a friend
template <class TYPE>
class SvcFactory;
 
class MetaDataSvc : public extends<::AthService,
                                    IAddressProvider,
                                    IIncidentListener,
                                    IAthMetaDataSvc,
                                    IIoComponent>
{
  // Allow the factory class access to the constructor
  friend class SvcFactory<MetaDataSvc>;  // <-- obsolete, remove
 
 public:  // Constructor and Destructor
  MetaDataSvc(const std::string& name, ISvcLocator* pSvcLocator);
  virtual ~MetaDataSvc();
 
  static const InterfaceID& interfaceID() { return IID_MetaDataSvc; }
 
 public:  // Non-static members
  virtual StatusCode initialize() override;
  virtual StatusCode stop() override;
  virtual StatusCode finalize() override;
  virtual StatusCode newMetadataSource(const Incident& /* inc */);
 
  virtual StatusCode retireMetadataSource(const Incident& /* inc */);
  virtual StatusCode prepareOutput();
 
  virtual StatusCode prepareOutput(const std::string& outputName);
 
  virtual StatusCode shmProxy(const std::string& filename) override;
  StatusCode queryInterface(const InterfaceID& riid,
                            void** ppvInterface) override;
 
  StatusCode preLoadAddresses(StoreID::type /* storeID */,
                              IAddressProvider::tadList& /* tads */) override {
    return StatusCode::SUCCESS;
  }
 
  StatusCode loadAddresses(StoreID::type storeID,
                           IAddressProvider::tadList& tads) override;
 
  StatusCode updateAddress(StoreID::type /* storeID */,
                           SG::TransientAddress* /* tad */,
                           const EventContext& /* ctx */) override {
    return StatusCode::FAILURE;
  }
  virtual void handle(const Incident& incident) override;
 
  StatusCode transitionMetaDataFile(const std::string& outputConn, bool disconnect);
 
  virtual StatusCode io_reinit() override;
 
  StatusCode rootOpenAction(FILEMGR_CALLBACK_ARGS);
 
  virtual StoreGateSvc* outputDataStore() const override final {
    return &*m_outputDataStore;
  }
 
  virtual const std::string currentRangeID() const override final;
 
  CLID remapMetaContCLID(const CLID& item_id) const;
 
  class ToolLockGuard {
   public:
    ToolLockGuard(const MetaDataSvc& mds) : m_mds(mds) { m_mds.lockTools(); }
    ~ToolLockGuard() { m_mds.unlockTools(); }
    ToolLockGuard(const ToolLockGuard&) = delete;
    void operator=(const ToolLockGuard&) = delete;
 
   private:
    const MetaDataSvc& m_mds;
  };
 
  void lockTools() const;
  void unlockTools() const;
 
  void recordHook(const std::type_info&) override;
  void removeHook(const std::type_info&) override;
 
  std::string removeStreamFromKey(std::string& key);
 
  virtual std::set<std::string> getPerStreamKeysFor(const std::string& key ) const override final;
 
 private:
  StatusCode addProxyToInputMetaDataStore(const std::string& tokenStr);
  StatusCode initInputMetaDataStore(const std::string& fileName);
 
 private:  // data
  ServiceHandle<StoreGateSvc> m_inputDataStore;
  ServiceHandle<StoreGateSvc> m_outputDataStore;
  ServiceHandle<IAddressCreator> m_addrCrtr;
  ServiceHandle<IFileMgr> m_fileMgr;
  ServiceHandle<IIncidentSvc> m_incSvc;
  ServiceHandle<OutputStreamSequencerSvc> m_outSeqSvc;
  ServiceHandle<IClassIDSvc> m_classIDSvc{"ClassIDSvc", name()};
 
  long m_storageType;
  bool m_clearedInputDataStore;
  bool m_clearedOutputDataStore;
  bool m_allowMetaDataStop;
  bool m_outputPrepared;
  std::map<std::string, CLID> m_persToClid;
  std::map<CLID, std::string> m_toolForClid;
 
  std::set<CLID>        m_handledClasses;
  const std::string     m_streamInKeyMark = "__STREAM[";
 
  std::map< std::string, std::set<std::string> > m_streamKeys;
 
 private:  // properties
  StringProperty m_metaDataCont;
  ToolHandleArray<IMetaDataTool> m_metaDataTools;
};
 
#endif