ATLAS Offline Software
Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
AddressRemappingSvc Class Reference

This class provides the interface to the LCG POOL persistency software. More...

#include <AddressRemappingSvc.h>

Inheritance diagram for AddressRemappingSvc:
Collaboration diagram for AddressRemappingSvc:

Public Member Functions

 AddressRemappingSvc (const std::string &name, ISvcLocator *pSvcLocator)
 Standard Service Constructor. More...
 
virtual ~AddressRemappingSvc ()
 Destructor. More...
 
virtual StatusCode initialize ATLAS_NOT_THREAD_SAFE () override
 Required of all Gaudi services: More...
 
virtual StatusCode finalize () override
 Required of all Gaudi services: More...
 
virtual StatusCode preLoadAddresses (StoreID::type storeID, IAddressProvider::tadList &tads) override
 Get all addresses from provider. More...
 
virtual StatusCode loadAddresses (StoreID::type storeID, IAddressProvider::tadList &tads) override
 Implementation of the loadAddresses function without any functionality. More...
 
virtual StatusCode updateAddress (StoreID::type, SG::TransientAddress *pTad, const EventContext &ctx) override
 Update a transient address. More...
 
virtual const IInputRename::InputRenameRCU_t * inputRenameMap () const override
 Retrieve a pointer to the input rename map. More...
 

Private Types

using InputRenameMap_t = Athena::InputRenameMap_t
 Map of sgkey->sgkey for input renames. More...
 
using InputRenameRCU_t = Athena::IInputRename::InputRenameRCU_t
 

Private Member Functions

CLID getClid (std::string type) const
 
StatusCode preLoadAddressesConst (StoreID::type storeID, IAddressProvider::tadList &tads) const
 
StatusCode updateAddressConst (StoreID::type, SG::TransientAddress *pTad, const EventContext &ctx) const
 
StatusCode loadAddressesConst (IAddressProvider::tadList &tads) const
 
void addInputRenames (const InputRenameMap_t &toadd) const
 Merge in additional input rename mappings. More...
 
StatusCode initInputRenames ATLAS_NOT_THREAD_SAFE ()
 Set up input rename mappings during initialization. More...
 
StatusCode renameTads (IAddressProvider::tadList &tads) const
 Scan TAD list and carry out any requested renamings. More...
 
void initDeletes ()
 
bool isDeleted (const SG::TransientAddress &tad) const
 

Private Attributes

ServiceHandle< IClassIDSvc > m_clidSvc
 
ServiceHandle< IProxyDictm_proxyDict
 
ServiceHandle< Athena::IRCUSvcm_RCUSvc
 
ServiceHandle< IAlgResourcePool > m_algResourcePool
 
StringArrayProperty m_overwriteMaps {this,"TypeKeyOverwriteMaps",{},"","OrderedSet<std::string>"}
 TypeKeyOverwriteMaps, map for type::key overwrites. More...
 
std::vector< SG::TransientAddressm_oldTads
 
std::vector< SG::TransientAddressm_newTads
 
CxxUtils::CachedValue< std::vector< SG::TransientAddress > > m_oldTadsCleaned
 
CxxUtils::CachedValue< std::vector< SG::TransientAddress > > m_newTadsCleaned
 
Gaudi::Property< std::vector< std::string > > m_typeKeyRenameMaps
 Property: list of requested input renames. More...
 
std::unique_ptr< InputRenameRCU_tm_inputRenames
 
Gaudi::Property< bool > m_skipBadRemappings
 
std::mutex m_deletesMutex
 
std::atomic< bool > m_haveDeletes =false
 
std::unordered_multimap< std::string, CLIDm_deletes
 

Detailed Description

This class provides the interface to the LCG POOL persistency software.

Definition at line 39 of file AddressRemappingSvc.h.

Member Typedef Documentation

◆ InputRenameMap_t

Map of sgkey->sgkey for input renames.

This object is exported via inputRenameMap and is synchronized via RCU.

Definition at line 112 of file AddressRemappingSvc.h.

◆ InputRenameRCU_t

Definition at line 113 of file AddressRemappingSvc.h.

Constructor & Destructor Documentation

◆ AddressRemappingSvc()

AddressRemappingSvc::AddressRemappingSvc ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Standard Service Constructor.

Definition at line 35 of file AddressRemappingSvc.cxx.

35  :
36  base_class(name, pSvcLocator),
37  m_clidSvc("ClassIDSvc", name),
38  m_RCUSvc("Athena::RCUSvc", name),
39  m_oldTads(),
40  m_newTads()
41 {}

◆ ~AddressRemappingSvc()

AddressRemappingSvc::~AddressRemappingSvc ( )
virtual

Destructor.

Definition at line 44 of file AddressRemappingSvc.cxx.

44  {
45 }

Member Function Documentation

◆ addInputRenames()

void AddressRemappingSvc::addInputRenames ( const InputRenameMap_t toadd) const
private

Merge in additional input rename mappings.

Parameters
toaddMappings to add.

Additional sgkey->sgkey input rename mappings are merged into the rename map, using RCU synchronization.

Definition at line 115 of file AddressRemappingSvc.cxx.

116 {
117  if (toadd.empty()) return;
118  // Ok, managed via RCU.
120  Athena::RCUUpdate<InputRenameMap_t> u (inputRenames);
121  auto newmap = std::make_unique<InputRenameMap_t> (*u);
122  for (const auto& p : toadd)
123  newmap->insert (p);
124  u.update (std::move (newmap));
125 }

◆ ATLAS_NOT_THREAD_SAFE() [1/2]

StatusCode initInputRenames AddressRemappingSvc::ATLAS_NOT_THREAD_SAFE ( )
private

Set up input rename mappings during initialization.

◆ ATLAS_NOT_THREAD_SAFE() [2/2]

virtual StatusCode initialize AddressRemappingSvc::ATLAS_NOT_THREAD_SAFE ( )
overridevirtual

Required of all Gaudi services:

◆ finalize()

StatusCode AddressRemappingSvc::finalize ( )
overridevirtual

Required of all Gaudi services:

Definition at line 175 of file AddressRemappingSvc.cxx.

176 {
177  ATH_CHECK( m_clidSvc.release() );
178  ATH_CHECK( m_proxyDict.release() );
179  ATH_CHECK( m_RCUSvc.release() );
180  ATH_CHECK( m_algResourcePool.release() );
182  return(StatusCode::SUCCESS);
183 }

◆ getClid()

CLID AddressRemappingSvc::getClid ( std::string  type) const
private

Definition at line 480 of file AddressRemappingSvc.cxx.

480  {
481  CLID clid(atoi(type.c_str())); // Is type a CLID?
482  if (clid == 0) { // or not
483  if (!m_clidSvc->getIDOfTypeName(type, clid).isSuccess()) {
484  return(0);
485  }
486  }
487  return(clid);
488 }

◆ initDeletes()

void AddressRemappingSvc::initDeletes ( )
private

Definition at line 498 of file AddressRemappingSvc.cxx.

499 {
500  if (m_haveDeletes) return;
501 
502  std::list<IAlgorithm*> algs = m_algResourcePool->getFlatAlgList();
503 
504  std::scoped_lock lock (m_deletesMutex);
505  if (m_haveDeletes) return;
506  m_haveDeletes = true;
507 
508  for (IAlgorithm* ialg : algs) {
509  if (Gaudi::Algorithm* alg = dynamic_cast<Gaudi::Algorithm*> (ialg)) {
510  // Need to ignore SGInputLoader; it'll have output deps
511  // on everything being read.
512  if (alg->name() == "SGInputLoader") continue;
513 
514  // Also ignore ViewDataVerifier algs, since they have no real output
515  if (alg->type() == "AthViews::ViewDataVerifier" ) continue;
516 
517  for (const DataObjID& dobj : alg->outputDataObjs()) {
518  static const std::string pref = "StoreGateSvc+";
519  if (dobj.key().rfind(pref, 0) != std::string::npos) {
520  std::string key = dobj.key().substr (pref.size());
521  m_deletes.emplace (key, dobj.clid());
522 
523  // If this looks like an xAOD type, then also make an entry
524  // for an aux store. Don't want to try to rely on BaseInfo here,
525  // as we may not have loaded the proper libraries yet.
526  // Second line of the test is to handle the tests in DataModelTest.
527  if (dobj.fullKey().find ("xAOD") != std::string::npos ||
528  dobj.fullKey().find ("cinfo") != std::string::npos)
529  {
530  m_deletes.emplace (key + "Aux.",
532  }
533  }
534  }
535  } else {
536  ATH_MSG_WARNING(ialg->name() << " doesn't seem to be an Algorithm" );
537  }
538 
539  }
540 }

◆ inputRenameMap()

const AddressRemappingSvc::InputRenameRCU_t * AddressRemappingSvc::inputRenameMap ( ) const
overridevirtual

Retrieve a pointer to the input rename map.

May return null if no renaming is to be done.

Definition at line 491 of file AddressRemappingSvc.cxx.

492 {
493  if (m_typeKeyRenameMaps.empty())
494  return nullptr;
495  return m_inputRenames.get();
496 }

◆ isDeleted()

bool AddressRemappingSvc::isDeleted ( const SG::TransientAddress tad) const
private

Definition at line 542 of file AddressRemappingSvc.cxx.

543 {
544  std::string key = tad.name();
545  std::scoped_lock lock (m_deletesMutex);
546  for (auto p : boost::make_iterator_range (m_deletes.equal_range (key))) {
547  CLID clid = p.second;
548  if (tad.transientID (clid)) {
549  return true;
550  }
551  }
552  return false;
553 }

◆ loadAddresses()

StatusCode AddressRemappingSvc::loadAddresses ( StoreID::type  storeID,
IAddressProvider::tadList tads 
)
overridevirtual

Implementation of the loadAddresses function without any functionality.

Definition at line 231 of file AddressRemappingSvc.cxx.

233 {
234  if (storeID == StoreID::EVENT_STORE) {
235  initDeletes();
236  ATH_CHECK( renameTads (tads) );
237  }
238  return loadAddressesConst (tads);
239 }

◆ loadAddressesConst()

StatusCode AddressRemappingSvc::loadAddressesConst ( IAddressProvider::tadList tads) const
private

Definition at line 241 of file AddressRemappingSvc.cxx.

242 {
243  if(!m_skipBadRemappings) return(StatusCode::SUCCESS);
245  return StatusCode::SUCCESS;
246  }
247 
248  std::vector<SG::TransientAddress> oldTadsCleaned = m_oldTads;
249  std::vector<SG::TransientAddress> newTadsCleaned = m_newTads;
250 
251  //do same as in preLoadAddresses, except check each tad will have a valid proxy to remap to
252  StatusCode status = m_proxyDict.retrieve();
253  if (!status.isSuccess()) {
254  ATH_MSG_ERROR("Unable to get the IProxyDict");
255  return(status);
256  }
257  for (std::vector<SG::TransientAddress>::iterator oldIter = oldTadsCleaned.begin(),
258  newIter = newTadsCleaned.begin(), oldIterEnd = oldTadsCleaned.end();
259  oldIter != oldIterEnd; ++oldIter, ++newIter)
260  {
261  CLID goodCLID = newIter->clID(); //newIter are the things we are remapping to
262  SG::TransientAddress::TransientClidSet clidvec(oldIter->transientID());
263  std::set<CLID> clidToKeep (clidvec.begin(), clidvec.end());
264  //try dataproxy, if it fails, try data proxy of next type
265  SG::DataProxy* dataProxy(m_proxyDict->proxy(goodCLID,newIter->name()/*the name of the address in the input file*/));
266  if(dataProxy==0) {
267  //remove goodCLID from the clidToKeep
268  clidToKeep.erase(goodCLID);
269  //try base types
270  const SG::BaseInfoBase* bi = SG::BaseInfoBase::find (newIter->clID());
271  if (bi) {
272  for (CLID goodCLID : bi->get_bases()) {
273  dataProxy = m_proxyDict->proxy(goodCLID, newIter->name());
274  if(dataProxy) break;
275  clidToKeep.erase(goodCLID); //was a bad CLID, so get rid of it
276  }
277  }
278  if(dataProxy) {
279  ATH_MSG_DEBUG("Remapping " << oldIter->clID() << "#" << oldIter->name() << " to base-class CLID: " << goodCLID << "#" << newIter->name());
280  //modify newIter to have these restricted clid instead
281  *newIter = SG::TransientAddress(goodCLID, newIter->name());
282  }
283  }
284  if(dataProxy==0) {
285  ATH_MSG_INFO("Skipping remapping of " << oldIter->clID() << "#" << oldIter->name() << " because no suitable remapping found");
286  continue;
287  }
288  SG::TransientAddress* tadd = new SG::TransientAddress(goodCLID,oldIter->name(),oldIter->address());
289  tadd->setAlias(oldIter->alias());//match the aliases
290  //also match the transientIDs, but only for the ok CLID
291  for(auto tIter = clidToKeep.begin(); tIter != clidToKeep.end(); ++tIter) {
292  if(goodCLID == *tIter) continue; //already added in constructor
293  tadd->setTransientID(goodCLID);
294  }
295  //replace oldIter tad with this new tadd if we have changed the primary CLID
296  if(oldIter->clID()!=tadd->clID()) {
297  *oldIter = *tadd; //relies on assignment operator
298  }
299  tads.push_back(tadd);
300  m_proxyDict->stringToKey(oldIter->name(), oldIter->clID());
301  m_proxyDict->stringToKey(newIter->name(), newIter->clID());
302  }
303 
304 
305  //only do this once, not every event .. FIXME: Should I be rechecking every new file? For now, we assume will not chain together different sample types
306  m_oldTadsCleaned.set (std::move (oldTadsCleaned));
307  m_newTadsCleaned.set (std::move (newTadsCleaned));
308 
309  return StatusCode::SUCCESS;
310 
311 }

◆ preLoadAddresses()

StatusCode AddressRemappingSvc::preLoadAddresses ( StoreID::type  storeID,
IAddressProvider::tadList tads 
)
overridevirtual

Get all addresses from provider.

Called before begin event.

Parameters
storeID[IN] store ID, this function only preloads detector store addresses.
tads[OUT] list of the transient addresses which were preloaded.

Definition at line 185 of file AddressRemappingSvc.cxx.

187 {
188  return preLoadAddressesConst (storeID, tads);
189 }

◆ preLoadAddressesConst()

StatusCode AddressRemappingSvc::preLoadAddressesConst ( StoreID::type  storeID,
IAddressProvider::tadList tads 
) const
private

Definition at line 190 of file AddressRemappingSvc.cxx.

192 {
193  if (storeID == StoreID::EVENT_STORE) {
194  ATH_CHECK( renameTads (tads) );
195  }
196 
197  const std::vector<SG::TransientAddress>* oldTads = nullptr;
198  const std::vector<SG::TransientAddress>* newTads = nullptr;
199 
200  if (m_skipBadRemappings) {
201  // We need to have the cleaned lists built in loadAddresses.
202  // If that hasn't already been done, return now.
204  return StatusCode::SUCCESS;
205  }
206  oldTads = m_oldTadsCleaned.ptr();
207  newTads = m_newTadsCleaned.ptr();
208  }
209  else {
210  // No cleaning needed.
211  oldTads = &m_oldTads;
212  newTads = &m_newTads;
213  }
214 
215  StatusCode status = m_proxyDict.retrieve();
216  if (!status.isSuccess()) {
217  ATH_MSG_ERROR("Unable to get the IProxyDict");
218  return(status);
219  }
220  for (std::vector<SG::TransientAddress>::const_iterator oldIter = oldTads->begin(),
221  newIter = newTads->begin(), oldIterEnd = oldTads->end();
222  oldIter != oldIterEnd; ++oldIter, ++newIter) {
223  SG::TransientAddress* tadd = new SG::TransientAddress(*oldIter);
224  tads.push_back(tadd);
225  m_proxyDict->stringToKey(oldIter->name(), oldIter->clID());
226  m_proxyDict->stringToKey(newIter->name(), newIter->clID());
227  }
228  return(StatusCode::SUCCESS);
229 }

◆ renameTads()

StatusCode AddressRemappingSvc::renameTads ( IAddressProvider::tadList tads) const
private

Scan TAD list and carry out any requested renamings.

Parameters
tadslist of TADs from previous providers.

Definition at line 365 of file AddressRemappingSvc.cxx.

366 {
367  // Fetch the current rename map using RCU.
369 
370  // We can exit early if there's nothing to do.
371  // FIXME: m_deletes will almost never be empty, but many times it will have
372  // no overlap with the input file. Should try to speed up by
373  // noticing/caching that somehow.
374  if (r->empty() && m_deletes.empty()) return StatusCode::SUCCESS;
375 
376  // We may discover additional remappings due to autosymlinking.
377  // Accumulate them here.
378  InputRenameMap_t newmap;
379 
380  // Loop over all TADs.
383  while (pos != end) {
384  SG::TransientAddress*& tad = *pos;
385 
386  // Has the object described by this TAD been renamed?
387  // FIXME: Handle renaming aliases.
388  CLID tad_clid = tad->clID();
389  SG::sgkey_t sgkey = m_proxyDict->stringToKey (tad->name(), tad_clid);
390  auto it = r->find (sgkey);
391  if (it != r->end()) {
392  const std::string& name_renamed = it->second.m_key;
393 
394  // We're doing a renaming. Make a new TAD with the new name.
395  auto tad_new = std::make_unique<SG::TransientAddress>
396  (tad_clid, name_renamed,
397  tad->address(), tad->clearAddress());
398  for (CLID clid : tad->transientID()) {
399  if (clid == tad_clid) continue;
400  tad_new->setTransientID (clid);
401  SG::sgkey_t from_key = m_proxyDict->stringToKey (tad->name(), clid);
402  if (r->find(from_key) == r->end()) {
403  SG::sgkey_t to_key = m_proxyDict->stringToKey (name_renamed, clid);
404  newmap[from_key] = Athena::InputRenameEntry { to_key, name_renamed };
405  }
406  }
407 
408  size_t namelen = tad->name().size();
410  for (const std::string& a : tad->alias()) {
411  std::string a_renamed = a;
412 
413  SG::sgkey_t from_key = m_proxyDict->stringToKey (a_renamed, tad_clid);
414  auto it_a = r->find (from_key);
415  if (it_a != r->end()) {
416  a_renamed = it_a->second.m_key;
417  }
418 
419  if (strncmp (a_renamed.c_str(), tad->name().c_str(), namelen) == 0 &&
420  a_renamed[namelen] == '.')
421  {
422  a_renamed = name_renamed + a_renamed.substr (namelen, std::string::npos);
423  }
424 
425  newAliases.insert (a_renamed);
426  }
427  tad_new->setAlias (newAliases);
428  tad_new->setProvider (tad->provider(), tad->storeID());
429 
430  // Replace the old TAD in the list with the new one.
431  delete tad;
432  tad = tad_new.release();
433 
434  ++pos;
435  }
436 
437  else if (isDeleted (*tad)) {
438  // Rename the existing TAD to end in _DELETED.
439  // Drop symlinks in the process.
440  auto tad_new = std::make_unique<SG::TransientAddress>
441  (tad->clID(), tad->name() + "_DELETED",
442  tad->address(), tad->clearAddress());
443  tad_new->setProvider (tad->provider(), tad->storeID());
444  // Preserve alias information, also renaming them to end in _DELETED.
445  for (const std::string& a : tad->alias()) {
446  tad_new->setAlias (a + "_DELETED");
447  }
448  // Replace the old TAD in the list with the new one.
449  delete tad;
450  tad = tad_new.release();
451 
452  ++pos;
453  }
454 
455  else {
456  // Check for renaming of an alias; eg., for renaming a dynamic vbl.
458  for (const std::string& a : aset) {
459  SG::sgkey_t from_key = m_proxyDict->stringToKey (a, tad_clid);
460  auto it_a = r->find (from_key);
461  if (it_a != r->end()) {
462  const std::string& s = it_a->second.m_key;
463  tad->removeAlias (a);
464  tad->setAlias (s);
465  }
466  }
467 
468  ++pos;
469  }
470  }
471 
472  // Publish additional remappings.
473  addInputRenames (newmap);
474 
475  return StatusCode::SUCCESS;
476 }

◆ updateAddress()

StatusCode AddressRemappingSvc::updateAddress ( StoreID::type  storeID,
SG::TransientAddress pTad,
const EventContext &  ctx 
)
overridevirtual

Update a transient address.

Do mapping from one address to another

Parameters
tad[IN] transient address to be updated.

Definition at line 313 of file AddressRemappingSvc.cxx.

316 {
317  return updateAddressConst (storeID, tad, ctx);
318 }

◆ updateAddressConst()

StatusCode AddressRemappingSvc::updateAddressConst ( StoreID::type  ,
SG::TransientAddress pTad,
const EventContext &  ctx 
) const
private

Definition at line 319 of file AddressRemappingSvc.cxx.

322 {
323  const std::vector<SG::TransientAddress>* oldTads = nullptr;
324  const std::vector<SG::TransientAddress>* newTads = nullptr;
325 
327  oldTads = m_oldTadsCleaned.ptr();
328  newTads = m_newTadsCleaned.ptr();
329  }
330  else {
331  // No cleaning needed.
332  oldTads = &m_oldTads;
333  newTads = &m_newTads;
334  }
335 
336  for (std::vector<SG::TransientAddress>::const_iterator oldIter = oldTads->begin(),
337  newIter = newTads->begin(), oldIterEnd = oldTads->end();
338  oldIter != oldIterEnd; ++oldIter, ++newIter) {
339  if (oldIter->transientID(tad->clID())
340  && (oldIter->name() == tad->name() || oldIter->alias().find(tad->name()) != oldIter->alias().end())) {
341  ATH_MSG_DEBUG("Overwrite for: " << tad->clID() << "#" << tad->name() << " -> " << newIter->clID() << "#" << newIter->name());
342  SG::DataProxy* dataProxy(m_proxyDict->proxy(newIter->clID(), newIter->name()));
343  if (dataProxy == 0) {
344  ATH_MSG_WARNING("Cannot get proxy for: " << newIter->clID() << "#" << newIter->name());
345  return(StatusCode::FAILURE);
346  }
347  GenericAddress* newGadd = 0;
348  if (dataProxy->isValidAddress()) newGadd = dynamic_cast<GenericAddress*>(dataProxy->address());
349  if (newGadd == 0) {
350  ATH_MSG_WARNING("Cannot get GenericAddress for: " << newIter->clID() << "#" << newIter->name());
351  return(StatusCode::FAILURE);
352  }
353  GenericAddress* oldGadd = new GenericAddress(newGadd->svcType(), tad->clID(), *newGadd->par(), tad->name(), *newGadd->ipar());
354  tad->setAddress(oldGadd);
355  return(StatusCode::SUCCESS);
356  }
357  }
358  return(StatusCode::FAILURE);
359 }

Member Data Documentation

◆ m_algResourcePool

ServiceHandle<IAlgResourcePool> AddressRemappingSvc::m_algResourcePool
private
Initial value:
{this,"AlgResourcePool","AlgResourcePool",
"Algorithm resource pool service."}

Definition at line 85 of file AddressRemappingSvc.h.

◆ m_clidSvc

ServiceHandle<IClassIDSvc> AddressRemappingSvc::m_clidSvc
private

Definition at line 81 of file AddressRemappingSvc.h.

◆ m_deletes

std::unordered_multimap<std::string, CLID> AddressRemappingSvc::m_deletes
private

Definition at line 122 of file AddressRemappingSvc.h.

◆ m_deletesMutex

std::mutex AddressRemappingSvc::m_deletesMutex
mutableprivate

Definition at line 120 of file AddressRemappingSvc.h.

◆ m_haveDeletes

std::atomic<bool> AddressRemappingSvc::m_haveDeletes =false
private

Definition at line 121 of file AddressRemappingSvc.h.

◆ m_inputRenames

std::unique_ptr<InputRenameRCU_t> AddressRemappingSvc::m_inputRenames
private

Definition at line 114 of file AddressRemappingSvc.h.

◆ m_newTads

std::vector<SG::TransientAddress> AddressRemappingSvc::m_newTads
private

Definition at line 91 of file AddressRemappingSvc.h.

◆ m_newTadsCleaned

CxxUtils::CachedValue<std::vector<SG::TransientAddress> > AddressRemappingSvc::m_newTadsCleaned
private

Definition at line 98 of file AddressRemappingSvc.h.

◆ m_oldTads

std::vector<SG::TransientAddress> AddressRemappingSvc::m_oldTads
private

Definition at line 90 of file AddressRemappingSvc.h.

◆ m_oldTadsCleaned

CxxUtils::CachedValue<std::vector<SG::TransientAddress> > AddressRemappingSvc::m_oldTadsCleaned
private

Definition at line 97 of file AddressRemappingSvc.h.

◆ m_overwriteMaps

StringArrayProperty AddressRemappingSvc::m_overwriteMaps {this,"TypeKeyOverwriteMaps",{},"","OrderedSet<std::string>"}
private

TypeKeyOverwriteMaps, map for type::key overwrites.

Definition at line 89 of file AddressRemappingSvc.h.

◆ m_proxyDict

ServiceHandle<IProxyDict> AddressRemappingSvc::m_proxyDict
private
Initial value:
{this,"ProxyDict","StoreGateSvc",
"the IProxyDict we want to apply the remapping to (by default the event store)"}

Definition at line 82 of file AddressRemappingSvc.h.

◆ m_RCUSvc

ServiceHandle<Athena::IRCUSvc> AddressRemappingSvc::m_RCUSvc
private

Definition at line 84 of file AddressRemappingSvc.h.

◆ m_skipBadRemappings

Gaudi::Property<bool> AddressRemappingSvc::m_skipBadRemappings
private
Initial value:
{this,"SkipBadRemappings",false,
"If true, will delay the remapping setup until the first load, and will check against the given file"}

Definition at line 116 of file AddressRemappingSvc.h.

◆ m_typeKeyRenameMaps

Gaudi::Property<std::vector<std::string> > AddressRemappingSvc::m_typeKeyRenameMaps
private
Initial value:
{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>"}

Property: list of requested input renames.

Definition at line 101 of file AddressRemappingSvc.h.


The documentation for this class was generated from the following files:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
python.PyAthenaComps.algs
algs
Definition: PyAthenaComps.py:41
beamspotman.r
def r
Definition: beamspotman.py:676
common.sgkey
def sgkey(tool)
Definition: common.py:1028
AddressRemappingSvc::isDeleted
bool isDeleted(const SG::TransientAddress &tad) const
Definition: AddressRemappingSvc.cxx:542
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:50
AddressRemappingSvc::m_skipBadRemappings
Gaudi::Property< bool > m_skipBadRemappings
Definition: AddressRemappingSvc.h:116
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
CxxUtils::CachedValue::ptr
const T * ptr() const
Return a pointer to the cached value.
SGout2dot.alg
alg
Definition: SGout2dot.py:243
Athena::RCUUpdate
Helper to update data in a RCUObject.
Definition: RCUObject.h:138
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
SG::TransientAddress::storeID
StoreID::type storeID() const
Definition: TransientAddress.h:311
AddressRemappingSvc::addInputRenames
void addInputRenames(const InputRenameMap_t &toadd) const
Merge in additional input rename mappings.
Definition: AddressRemappingSvc.cxx:115
CxxUtils::CachedValue::isValid
bool isValid() const
Test to see if the value is valid.
AddressRemappingSvc::m_inputRenames
std::unique_ptr< InputRenameRCU_t > m_inputRenames
Definition: AddressRemappingSvc.h:114
SG::TransientAddress::setAlias
void setAlias(const std::string &key)
set alias'
Definition: TransientAddress.h:251
skel.it
it
Definition: skel.GENtoEVGEN.py:396
AddressRemappingSvc::m_oldTads
std::vector< SG::TransientAddress > m_oldTads
Definition: AddressRemappingSvc.h:90
AddressRemappingSvc::m_oldTadsCleaned
CxxUtils::CachedValue< std::vector< SG::TransientAddress > > m_oldTadsCleaned
Definition: AddressRemappingSvc.h:97
SG::TransientAddress
Definition: TransientAddress.h:32
SG::TransientAddress::TransientClidSet
std::vector< CLID > TransientClidSet
Strictly a set, but there shouldn't be more than a handful of entries, so store it as a sorted vector...
Definition: TransientAddress.h:38
SG::TransientAddress::removeAlias
bool removeAlias(const std::string &key)
remove alias from proxy
Definition: TransientAddress.h:271
AddressRemappingSvc::m_haveDeletes
std::atomic< bool > m_haveDeletes
Definition: AddressRemappingSvc.h:121
TestSUSYToolsAlg.pref
pref
Definition: TestSUSYToolsAlg.py:80
SG::BaseInfoBase::get_bases
const std::vector< CLID > & get_bases() const
Return the class IDs of all known bases of T (that have class IDs).
Definition: BaseInfo.cxx:304
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
AddressRemappingSvc::initDeletes
void initDeletes()
Definition: AddressRemappingSvc.cxx:498
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
AddressRemappingSvc::m_clidSvc
ServiceHandle< IClassIDSvc > m_clidSvc
Definition: AddressRemappingSvc.h:81
SG::TransientAddress::name
const std::string & name() const
Get the primary (hashed) SG key.
Definition: TransientAddress.h:208
AddressRemappingSvc::m_newTadsCleaned
CxxUtils::CachedValue< std::vector< SG::TransientAddress > > m_newTadsCleaned
Definition: AddressRemappingSvc.h:98
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
Athena::InputRenameEntry
Type of the input rename map: sgkey_t -> sgkey_t.
Definition: InputRenameMap.h:28
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
SG::TransientAddress::alias
const TransientAliasSet & alias() const
set the clearAddress flag: IOA will not be deleted in proxy
Definition: TransientAddress.h:278
AddressRemappingSvc::renameTads
StatusCode renameTads(IAddressProvider::tadList &tads) const
Scan TAD list and carry out any requested renamings.
Definition: AddressRemappingSvc.cxx:365
SG::TransientAddress::provider
IAddressProvider * provider()
Definition: TransientAddress.h:306
AddressRemappingSvc::m_algResourcePool
ServiceHandle< IAlgResourcePool > m_algResourcePool
Definition: AddressRemappingSvc.h:85
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Athena::RCURead
Helper to read data from a RCUObject.
Definition: RCUObject.h:136
SG::TransientAddress::clID
CLID clID() const
Retrieve string key:
Definition: TransientAddress.h:201
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:40
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AddressRemappingSvc::InputRenameMap_t
Athena::InputRenameMap_t InputRenameMap_t
Map of sgkey->sgkey for input renames.
Definition: AddressRemappingSvc.h:112
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
AddressRemappingSvc::m_RCUSvc
ServiceHandle< Athena::IRCUSvc > m_RCUSvc
Definition: AddressRemappingSvc.h:84
AddressRemappingSvc::m_deletes
std::unordered_multimap< std::string, CLID > m_deletes
Definition: AddressRemappingSvc.h:122
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
SG::BaseInfoBase::find
static const BaseInfoBase * find(CLID clid)
Find the BaseInfoBase instance for clid.
Definition: BaseInfo.cxx:569
SG::TransientAddress::setTransientID
void setTransientID(CLID id)
get transient CLID's
Definition: TransientAddress.cxx:142
SG::sgkey_t
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition: CxxUtils/CxxUtils/sgkey_t.h:32
CxxUtils::CachedValue::set
void set(const T &val) const
Set the value, assuming it is currently invalid.
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
AddressRemappingSvc::preLoadAddressesConst
StatusCode preLoadAddressesConst(StoreID::type storeID, IAddressProvider::tadList &tads) const
Definition: AddressRemappingSvc.cxx:190
AddressRemappingSvc::m_proxyDict
ServiceHandle< IProxyDict > m_proxyDict
Definition: AddressRemappingSvc.h:82
a
TList * a
Definition: liststreamerinfos.cxx:10
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
SG::BaseInfoBase
The non-template portion of the BaseInfo implementation.
Definition: Control/AthenaKernel/AthenaKernel/BaseInfo.h:451
AddressRemappingSvc::updateAddressConst
StatusCode updateAddressConst(StoreID::type, SG::TransientAddress *pTad, const EventContext &ctx) const
Definition: AddressRemappingSvc.cxx:319
AddressRemappingSvc::m_typeKeyRenameMaps
Gaudi::Property< std::vector< std::string > > m_typeKeyRenameMaps
Property: list of requested input renames.
Definition: AddressRemappingSvc.h:101
AddressRemappingSvc::loadAddressesConst
StatusCode loadAddressesConst(IAddressProvider::tadList &tads) const
Definition: AddressRemappingSvc.cxx:241
SG::TransientAddress::clearAddress
void clearAddress(const bool &flag)
Return the clearAddress flag.
Definition: TransientAddress.h:285
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
AddressRemappingSvc::InputRenameRCU_t
Athena::IInputRename::InputRenameRCU_t InputRenameRCU_t
Definition: AddressRemappingSvc.h:113
merge.status
status
Definition: merge.py:17
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
StoreID::EVENT_STORE
@ EVENT_STORE
Definition: StoreID.h:26
SG::DataProxy
Definition: DataProxy.h:45
SG::TransientAddress::TransientAliasSet
std::set< std::string > TransientAliasSet
Definition: TransientAddress.h:40
SG::TransientAddress::transientID
bool transientID(CLID id) const
set transient CLID's
Definition: TransientAddress.h:236
AddressRemappingSvc::m_deletesMutex
std::mutex m_deletesMutex
Definition: AddressRemappingSvc.h:120
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
AddressRemappingSvc::m_newTads
std::vector< SG::TransientAddress > m_newTads
Definition: AddressRemappingSvc.h:91