AddressRemappingSvc Class Reference

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

#include <AddressRemappingSvc.h>

Inheritance diagram for AddressRemappingSvc:

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

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

Private Member Functions
CLID	getClid (const 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.
StatusCode initInputRenames	ATLAS_NOT_THREAD_SAFE ()
	Set up input rename mappings during initialization.
StatusCode	renameTads (IAddressProvider::tadList &tads) const
	Scan TAD list and carry out any requested renamings.
void	initDeletes ()
bool	isDeleted (const SG::TransientAddress &tad) const

Private Attributes
ServiceHandle< IClassIDSvc >	m_clidSvc
ServiceHandle< IProxyDict >	m_proxyDict
ServiceHandle< Athena::IRCUSvc >	m_RCUSvc
ServiceHandle< IAlgResourcePool >	m_algResourcePool
StringArrayProperty	m_overwriteMaps {this,"TypeKeyOverwriteMaps",{},"","OrderedSet<std::string>"}
	TypeKeyOverwriteMaps, map for type#key overwrites.
std::vector< SG::TransientAddress >	m_oldTads
std::vector< SG::TransientAddress >	m_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.
std::unique_ptr< InputRenameRCU_t >	m_inputRenames
Gaudi::Property< bool >	m_skipBadRemappings
std::mutex	m_deletesMutex
std::atomic< bool >	m_haveDeletes =false
std::unordered_multimap< std::string, CLID >	m_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

using AddressRemappingSvc::InputRenameMap_t = Athena::InputRenameMap_t

private

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

using AddressRemappingSvc::InputRenameRCU_t = Athena::IInputRename::InputRenameRCU_t

private

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.

                                                                                        :
  base_class(name, pSvcLocator),
  m_clidSvc("ClassIDSvc", name),
  m_RCUSvc("Athena::RCUSvc", name),
  m_oldTads(),
  m_newTads()
{}

~AddressRemappingSvc()

AddressRemappingSvc::~AddressRemappingSvc ( )

virtual

Destructor.

Definition at line 44 of file AddressRemappingSvc.cxx.

                                          {
}

Member Function Documentation

addInputRenames()

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

private

Merge in additional input rename mappings.

Parameters

toadd

Mappings to add.

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

Definition at line 113 of file AddressRemappingSvc.cxx.

{
  if (toadd.empty()) return;
  // Ok, managed via RCU.
  InputRenameRCU_t& inputRenames ATLAS_THREAD_SAFE = *m_inputRenames;
  Athena::RCUUpdate<InputRenameMap_t> u (inputRenames);
  auto newmap = std::make_unique<InputRenameMap_t> (*u);
  for (const auto& p : toadd)
    newmap->insert (p);
  u.update (std::move (newmap));
}

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 173 of file AddressRemappingSvc.cxx.

{
   ATH_CHECK( m_clidSvc.release() );
   ATH_CHECK( m_proxyDict.release() );
   ATH_CHECK( m_RCUSvc.release() );
   ATH_CHECK( m_algResourcePool.release() );
   ATH_CHECK( ::AthService::finalize() );
   return(StatusCode::SUCCESS);
}

getClid()

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

private

Definition at line 480 of file AddressRemappingSvc.cxx.

                                                             {
   CLID clid(atoi(type.c_str())); // Is type a CLID? 
   if (clid == 0) { // or not
      if (!m_clidSvc->getIDOfTypeName(type, clid).isSuccess()) {
         return(0);
      }
   }
   return(clid);
}

initDeletes()

void AddressRemappingSvc::initDeletes ( )

private

Definition at line 498 of file AddressRemappingSvc.cxx.

{
  if (m_haveDeletes) return;
 
  std::list<IAlgorithm*> algs = m_algResourcePool->getFlatAlgList();
 
  std::scoped_lock lock (m_deletesMutex);
  if (m_haveDeletes) return;
  m_haveDeletes = true;
 
  for (IAlgorithm* ialg : algs) {
    if (Gaudi::Algorithm* alg = dynamic_cast<Gaudi::Algorithm*> (ialg)) {
      // Need to ignore SGInputLoader; it'll have output deps
      // on everything being read.
      if (alg->name() == "SGInputLoader") continue;
 
      // Also ignore ViewDataVerifier algs, since they have no real output
      if (alg->type() == "AthViews::ViewDataVerifier" ) continue;
 
      for (const DataObjID& dobj : alg->outputDataObjs()) {
        static const std::string pref = "StoreGateSvc+";
        if (dobj.key().rfind(pref, 0) != std::string::npos) {
          std::string key = dobj.key().substr (pref.size());
          m_deletes.emplace (key, dobj.clid());
 
          // If this looks like an xAOD type, then also make an entry
          // for an aux store.  Don't want to try to rely on BaseInfo here,
          // as we may not have loaded the proper libraries yet.
          // Second line of the test is to handle the tests in DataModelTest.
          if (dobj.fullKey().find ("xAOD") != std::string::npos ||
              dobj.fullKey().find ("cinfo") != std::string::npos)
          {
            m_deletes.emplace (key + "Aux.",
                               ClassID_traits<SG::IConstAuxStore>::ID());
          }
        }
      }
    } else {
      ATH_MSG_WARNING(ialg->name() << " doesn't seem to be an Algorithm" );
    }
    
  }
}

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.

{
  if (m_typeKeyRenameMaps.empty())
    return nullptr;
  return m_inputRenames.get();
}

isDeleted()

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

private

Definition at line 542 of file AddressRemappingSvc.cxx.

{
  std::string key = tad.name();
  std::scoped_lock lock (m_deletesMutex);
  auto xrange = m_deletes.equal_range (key);
  for (const auto& p : std::ranges::subrange(xrange.first,xrange.second)) {
    CLID clid = p.second;
    if (tad.transientID (clid)) {
      return true;
    }
  }
  return false;
}

loadAddresses()

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

overridevirtual

Implementation of the loadAddresses function without any functionality.

Definition at line 229 of file AddressRemappingSvc.cxx.

{
  if (storeID == StoreID::EVENT_STORE) {
    initDeletes();
    ATH_CHECK( renameTads (tads) );
  }
  return loadAddressesConst (tads);
}

loadAddressesConst()

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

private

Definition at line 239 of file AddressRemappingSvc.cxx.

{
   if(!m_skipBadRemappings) return(StatusCode::SUCCESS);
   if (m_oldTadsCleaned.isValid() && m_newTadsCleaned.isValid()) {
     return StatusCode::SUCCESS;
   }
 
   std::vector<SG::TransientAddress> oldTadsCleaned = m_oldTads;
   std::vector<SG::TransientAddress> newTadsCleaned = m_newTads;
 
   //do same as in preLoadAddresses, except check each tad will have a valid proxy to remap to 
   StatusCode status = m_proxyDict.retrieve();
   if (!status.isSuccess()) {
      ATH_MSG_ERROR("Unable to get the IProxyDict");
      return(status);
   }
   for (std::vector<SG::TransientAddress>::iterator oldIter = oldTadsCleaned.begin(),
           newIter = newTadsCleaned.begin(), oldIterEnd = oldTadsCleaned.end();
           oldIter != oldIterEnd; ++oldIter, ++newIter)
   {
      CLID goodCLID = newIter->clID(); //newIter are the things we are remapping to 
      SG::TransientAddress::TransientClidSet clidvec(oldIter->transientID());
      std::set<CLID> clidToKeep (clidvec.begin(), clidvec.end());
      //try dataproxy, if it fails, try data proxy of next type 
      SG::DataProxy* dataProxy(m_proxyDict->proxy(goodCLID,newIter->name()/*the name of the address in the input file*/));
      if(dataProxy==0) {
         //remove goodCLID from the clidToKeep 
         clidToKeep.erase(goodCLID);
         //try base types 
         const SG::BaseInfoBase* bi = SG::BaseInfoBase::find (newIter->clID());
         if (bi) {
            for (CLID goodCLID : bi->get_bases()) {
               dataProxy = m_proxyDict->proxy(goodCLID, newIter->name());
               if(dataProxy) break;
               clidToKeep.erase(goodCLID); //was a bad CLID, so get rid of it
            }
         }
         if(dataProxy) {
            ATH_MSG_DEBUG("Remapping " << oldIter->clID() << "#" << oldIter->name() << " to base-class CLID: " << goodCLID << "#" << newIter->name());
            //modify newIter to have these restricted clid instead 
            *newIter = SG::TransientAddress(goodCLID, newIter->name());
         }
      }
      if(dataProxy==0) {
         ATH_MSG_INFO("Skipping remapping of " << oldIter->clID() << "#" << oldIter->name() << " because no suitable remapping found");
         continue;
      }
      SG::TransientAddress* tadd = new SG::TransientAddress(goodCLID,oldIter->name(),oldIter->address());
      tadd->setAlias(oldIter->alias());//match the aliases  
      //also match the transientIDs, but only for the ok CLID 
      for(auto tIter = clidToKeep.begin(); tIter != clidToKeep.end(); ++tIter) {
         if(goodCLID == *tIter) continue; //already added in constructor 
         tadd->setTransientID(goodCLID);
      }
      //replace oldIter tad with this new tadd if we have changed the primary CLID
      if(oldIter->clID()!=tadd->clID()) {
         *oldIter = *tadd; //relies on assignment operator
      }
      tads.push_back(tadd);
      m_proxyDict->stringToKey(oldIter->name(), oldIter->clID());
      m_proxyDict->stringToKey(newIter->name(), newIter->clID());
   }
 
 
   //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
   m_oldTadsCleaned.set (std::move (oldTadsCleaned));
   m_newTadsCleaned.set (std::move (newTadsCleaned));
 
   return StatusCode::SUCCESS;
 
}

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 183 of file AddressRemappingSvc.cxx.

{
  return preLoadAddressesConst (storeID, tads);
}

preLoadAddressesConst()

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

private

Definition at line 188 of file AddressRemappingSvc.cxx.

{
   if (storeID == StoreID::EVENT_STORE) {
     ATH_CHECK( renameTads (tads) );
   }
 
   const std::vector<SG::TransientAddress>* oldTads = nullptr;
   const std::vector<SG::TransientAddress>* newTads = nullptr;
 
   if (m_skipBadRemappings) {
     // We need to have the cleaned lists built in loadAddresses.
     // If that hasn't already been done, return now.
     if (!m_oldTadsCleaned.isValid() || ! m_newTadsCleaned.isValid()) {
       return StatusCode::SUCCESS;
     }
     oldTads = m_oldTadsCleaned.ptr();
     newTads = m_newTadsCleaned.ptr();
   }
   else {
     // No cleaning needed.
     oldTads = &m_oldTads;
     newTads = &m_newTads;
   }
 
   StatusCode status = m_proxyDict.retrieve();
   if (!status.isSuccess()) {
      ATH_MSG_ERROR("Unable to get the IProxyDict");
      return(status);
   }
   for (std::vector<SG::TransientAddress>::const_iterator oldIter = oldTads->begin(),
           newIter = newTads->begin(), oldIterEnd = oldTads->end();
           oldIter != oldIterEnd; ++oldIter, ++newIter) {
      SG::TransientAddress* tadd = new SG::TransientAddress(*oldIter);
      tads.push_back(tadd);
      m_proxyDict->stringToKey(oldIter->name(), oldIter->clID());
      m_proxyDict->stringToKey(newIter->name(), newIter->clID());
   }
   return(StatusCode::SUCCESS);
}

renameTads()

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

private

Scan TAD list and carry out any requested renamings.

Parameters

tads	list of TADs from previous providers.

Definition at line 364 of file AddressRemappingSvc.cxx.

{
  // Fetch the current rename map using RCU.
  Athena::RCURead<InputRenameMap_t> r (*m_inputRenames);
 
  // We can exit early if there's nothing to do.
  // FIXME: m_deletes will almost never be empty, but many times it will have
  // no overlap with the input file.  Should try to speed up by
  // noticing/caching that somehow.
  {
    std::scoped_lock lock (m_deletesMutex);
    if (r->empty() && m_deletes.empty()) return StatusCode::SUCCESS;
  }
 
  // We may discover additional remappings due to autosymlinking.
  // Accumulate them here.
  InputRenameMap_t newmap;
 
  // Loop over all TADs.
  IAddressProvider::tadList::iterator pos = tads.begin();
  IAddressProvider::tadList::iterator end = tads.end();
  while (pos != end) {
    SG::TransientAddress*& tad = *pos;
 
    // Has the object described by this TAD been renamed?
    // FIXME: Handle renaming aliases.
    CLID tad_clid = tad->clID();
    SG::sgkey_t sgkey = m_proxyDict->stringToKey (tad->name(), tad_clid);
    auto it = r->find (sgkey);
    if (it != r->end()) {
      const std::string& name_renamed = it->second.m_key;
 
      // We're doing a renaming.  Make a new TAD with the new name.
      auto tad_new = std::make_unique<SG::TransientAddress>
        (tad_clid, name_renamed,
         tad->address(), tad->clearAddress());
      for (CLID clid : tad->transientID()) {
        if (clid == tad_clid) continue;
        tad_new->setTransientID (clid);
        SG::sgkey_t from_key = m_proxyDict->stringToKey (tad->name(), clid);
        if (r->find(from_key) == r->end()) {
          SG::sgkey_t to_key = m_proxyDict->stringToKey (name_renamed, clid);
          newmap[from_key] = Athena::InputRenameEntry { to_key, name_renamed };
        }
      }
 
      size_t namelen = tad->name().size();
      for (const std::string& a : tad->alias()) {
        std::string a_renamed = a;
 
        SG::sgkey_t from_key = m_proxyDict->stringToKey (a_renamed, tad_clid);
        auto it_a = r->find (from_key);
        if (it_a != r->end()) {
          a_renamed = it_a->second.m_key;
        }
 
        if (strncmp (a_renamed.c_str(), tad->name().c_str(), namelen) == 0 &&
            a_renamed[namelen] == '.')
        {
            a_renamed = name_renamed + a_renamed.substr (namelen, std::string::npos);
        }
          
        tad_new->setAlias (a_renamed);
      }
      tad_new->setProvider (tad->provider(), tad->storeID());
 
      // Replace the old TAD in the list with the new one.
      delete tad;
      tad = tad_new.release();
 
      ++pos;
    }
 
    else if (isDeleted (*tad)) {
      // Rename the existing TAD to end in _DELETED.
      // Drop symlinks in the process.
      auto tad_new = std::make_unique<SG::TransientAddress>
        (tad->clID(), tad->name() + "_DELETED",
         tad->address(), tad->clearAddress());
      tad_new->setProvider (tad->provider(), tad->storeID());
      // Preserve alias information, also renaming them to end in _DELETED.
      for (const std::string& a : tad->alias()) {
        tad_new->setAlias (a + "_DELETED");
      }
      // Replace the old TAD in the list with the new one.
      delete tad;
      tad = tad_new.release();
 
      ++pos;
    }
 
    else {
      // Check for renaming of an alias; eg., for renaming a dynamic vbl.
      SG::TransientAddress::TransientAliasSet aset = tad->alias();
      for (const std::string& a : aset) {
        SG::sgkey_t from_key = m_proxyDict->stringToKey (a, tad_clid);
        auto it_a = r->find (from_key);
        if (it_a != r->end()) {
          const std::string& s = it_a->second.m_key;
          tad->removeAlias (a);
          tad->setAlias (s);
        }
      }
 
      ++pos;
    }
  }
 
  // Publish additional remappings.
  addInputRenames (newmap);
 
  return StatusCode::SUCCESS;
}

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 311 of file AddressRemappingSvc.cxx.

{
  return updateAddressConst (storeID, tad, ctx);
}

updateAddressConst()

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

private

Definition at line 317 of file AddressRemappingSvc.cxx.

{
   const std::vector<SG::TransientAddress>* oldTads = nullptr;
   const std::vector<SG::TransientAddress>* newTads = nullptr;
 
   if (m_skipBadRemappings && m_oldTadsCleaned.isValid() && m_newTadsCleaned.isValid()) {
     oldTads = m_oldTadsCleaned.ptr();
     newTads = m_newTadsCleaned.ptr();
   }
   else {
     // No cleaning needed.
     oldTads = &m_oldTads;
     newTads = &m_newTads;
   }
 
   for (std::vector<SG::TransientAddress>::const_iterator oldIter = oldTads->begin(),
           newIter = newTads->begin(), oldIterEnd = oldTads->end();
           oldIter != oldIterEnd; ++oldIter, ++newIter) {
      if (oldIter->transientID(tad->clID()) &&
          (oldIter->name() == tad->name() || oldIter->hasAlias (tad->name())))
      {
         ATH_MSG_DEBUG("Overwrite for: " << tad->clID() << "#" << tad->name() << " -> " << newIter->clID() << "#" << newIter->name());
         SG::DataProxy* dataProxy(m_proxyDict->proxy(newIter->clID(), newIter->name()));
         if (dataProxy == 0) {
            ATH_MSG_WARNING("Cannot get proxy for: " << newIter->clID() << "#" << newIter->name());
            return(StatusCode::FAILURE);
         }
         GenericAddress* newGadd = 0;
     if (dataProxy->isValidAddress()) newGadd = dynamic_cast<GenericAddress*>(dataProxy->address());
         if (newGadd == 0) {
            ATH_MSG_WARNING("Cannot get GenericAddress for: " << newIter->clID() << "#" << newIter->name());
            return(StatusCode::FAILURE);
         }
         GenericAddress* oldGadd = new GenericAddress(newGadd->svcType(), tad->clID(), *newGadd->par(), tad->name(), *newGadd->ipar());
         tad->setAddress(oldGadd);
         return(StatusCode::SUCCESS);
      }
   }
   return(StatusCode::FAILURE);
}

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.

                                                   {this,"AlgResourcePool","AlgResourcePool",
      "Algorithm resource pool service."};

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.

{this,"TypeKeyOverwriteMaps",{},"","OrderedSet<std::string>"};

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.

                                       {this,"ProxyDict","StoreGateSvc",
      "the IProxyDict we want to apply the remapping to (by default the event store)"};

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.

                                         {this,"SkipBadRemappings",false,
      "If true, will delay the remapping setup until the first load, and will check against the given file"};

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.

                                                         {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>"};

---

The documentation for this class was generated from the following files:

• AddressRemappingSvc.h
• AddressRemappingSvc.cxx