MetaDataSvc.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 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/IAddressCreator.h"
#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 StoreGateSvc;
class IAlgTool;
class OutputStreamSequencerSvc;
 
namespace Io {
  class FileAttr;
}

class MetaDataSvc : public extends<::AthService,
                                    IAddressProvider,
                                    IIncidentListener,
                                    IAthMetaDataSvc,
                                    IIoComponent>
{
 public:
  using IService::interfaceID;

  MetaDataSvc(const std::string& name, ISvcLocator* pSvcLocator);
  virtual ~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 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:
    explicit 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{ this, "ConversionService", "AthenaPoolCnvSvc" };
  ServiceHandle<IFileMgr> m_fileMgr;
  ServiceHandle<IIncidentSvc> m_incSvc;
  ServiceHandle<OutputStreamSequencerSvc> m_outSeqSvc;
  ServiceHandle<IClassIDSvc> m_classIDSvc{"ClassIDSvc", name()};
 
  long m_storageType{0L};
  bool m_clearedInputDataStore{true};
  bool m_clearedOutputDataStore{false};
  bool m_allowMetaDataStop{false};
  bool m_outputPrepared{false};
  std::map<std::string_view, CLID> m_persToClid{};
 
  std::set<CLID>        m_handledClasses{};
  static constexpr std::string_view m_streamInKeyMark{"__STREAM["};
 
  std::map< std::string, std::set<std::string> > m_streamKeys{};
 
 private:  // properties
  Gaudi::Property<std::string> m_metaDataCont{this, "MetaDataContainer", ""};
  PublicToolHandleArray<IMetaDataTool> m_metaDataTools{this, "MetaDataTools", {}};
};
 
#endif