AddressRemappingSvc.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef SGCOMPS_ADDRESSREMAPPINGSVC_H
#define SGCOMPS_ADDRESSREMAPPINGSVC_H 1
 
#include "GaudiKernel/ClassID.h"
#include "GaudiKernel/ServiceHandle.h"
#include "Gaudi/Property.h"  // no forward decl: typedef
#include "AthenaKernel/IAddressProvider.h"
#include "AthenaKernel/IInputRename.h"
#include "AthenaKernel/RCUObject.h"
#include "GaudiKernel/IAlgResourcePool.h" 
#include "AthenaBaseComps/AthService.h"
#include "SGTools/TransientAddress.h"
#include "CxxUtils/CachedValue.h"
#include "CxxUtils/checker_macros.h"
 
#include <vector>
#include <string>
#include <mutex>
 
// Forward declarations
class IClassIDSvc;
class IProxyDict;
class IRCUSvc;
 
class AddressRemappingSvc
  : public extends<AthService, Athena::IInputRename, IAddressProvider>
{
 
public: 
 
  // Constructor and Destructor
   AddressRemappingSvc(const std::string& name, ISvcLocator* pSvcLocator);
   virtual ~AddressRemappingSvc();
 
public: // Non-static members
   virtual StatusCode initialize ATLAS_NOT_THREAD_SAFE () override;
   virtual StatusCode finalize() override;
 
   virtual StatusCode preLoadAddresses(StoreID::type storeID, IAddressProvider::tadList& tads) override;
 
   virtual StatusCode loadAddresses(StoreID::type storeID, IAddressProvider::tadList& tads) override;
 
  virtual StatusCode updateAddress(StoreID::type /*storeID*/,
                   SG::TransientAddress* pTad,
                                   const EventContext& ctx) override;
 
 
  virtual const IInputRename::InputRenameRCU_t* inputRenameMap() const override;
 
 
private: // Data
   ServiceHandle<IClassIDSvc> m_clidSvc;
  ServiceHandle<IProxyDict> m_proxyDict{this,"ProxyDict","StoreGateSvc",
      "the IProxyDict we want to apply the remapping to (by default the event store)"};
  ServiceHandle<Athena::IRCUSvc> m_RCUSvc;
  ServiceHandle<IAlgResourcePool> m_algResourcePool{this,"AlgResourcePool","AlgResourcePool",
      "Algorithm resource pool service."};
 
  StringArrayProperty m_overwriteMaps{this,"TypeKeyOverwriteMaps",{},"","OrderedSet<std::string>"};
  std::vector<SG::TransientAddress> m_oldTads;
  std::vector<SG::TransientAddress> m_newTads;
 
  // The old and new TADS list, possibly cleaned of nonexistent CLIDs.
  // If SkipBadRemappings is true, then for the first event, we defer
  // preloading the TADS until loadAddresses, where we can compare them
  // against what's in the event store.
  CxxUtils::CachedValue<std::vector<SG::TransientAddress> > m_oldTadsCleaned;
  CxxUtils::CachedValue<std::vector<SG::TransientAddress> > m_newTadsCleaned;
 
  Gaudi::Property<std::vector<std::string> >m_typeKeyRenameMaps{this,"TypeKeyRenameMaps",{},
      "List of renamings to apply to input objects.  This is distinct from the "
    "mappings given by TypeKeyOverwriteMaps in that objects listed under "
    "TypeKeyOverwriteMaps are accessible by both the old and new names; "
    "while for TypeKeyRenameMaps, only the new names are visible (so the old names "
    "may be rewritten).  Overwriting may also change the visible type of an object, "
    "while renaming may not.  Format of list elements is OLDNAME#TYPE->NEWNAME.","OrderedSet<std::string>"};
 
  using InputRenameMap_t = Athena::InputRenameMap_t;
  using InputRenameRCU_t = Athena::IInputRename::InputRenameRCU_t;
   std::unique_ptr<InputRenameRCU_t> m_inputRenames;
 
  Gaudi::Property<bool> m_skipBadRemappings{this,"SkipBadRemappings",false,
      "If true, will delay the remapping setup until the first load, and will check against the given file"};
 
   // This mutex protects the two following members.
   mutable std::mutex m_deletesMutex;
   std::atomic<bool> m_haveDeletes=false;
   std::unordered_multimap<std::string, CLID> m_deletes;
 
 
private:
   CLID getClid(std::string type) const;
 
   StatusCode preLoadAddressesConst(StoreID::type storeID, IAddressProvider::tadList& tads) const;
 
   StatusCode updateAddressConst(StoreID::type /*storeID*/,
                                 SG::TransientAddress* pTad,
                                 const EventContext& ctx) const;
 
  StatusCode loadAddressesConst(IAddressProvider::tadList& tads) const;
 
   void addInputRenames (const InputRenameMap_t& toadd) const;
 
 
   StatusCode initInputRenames ATLAS_NOT_THREAD_SAFE ();
   StatusCode renameTads (IAddressProvider::tadList& tads) const;
 
   void initDeletes();
   bool isDeleted (const SG::TransientAddress& tad) const;
};
#endif // !SGCOMPS_ADDRESSREMAPPINGSVC_H