ATLAS Offline Software
Control/SGTools/src/DataStore.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "SGTools/DataStore.h"
6 #include "SGTools/DataProxy.h"
7 #include "SGTools/exceptions.h"
9 #include "GaudiKernel/ClassID.h"
10 #include "GaudiKernel/MsgStream.h"
11 #include "GaudiKernel/Bootstrap.h"
12 #include "GaudiKernel/ISvcLocator.h"
13 #include "SGAudCore/ISGAudSvc.h"
15 #include "CxxUtils/SimpleUpdater.h"
18 
19 using namespace std;
20 using SG::DataStore;
21 using SG::DataProxy;
22 using SG::ProxyMap;
23 using SG::ProxyIterator;
25 
26 
31 DataStore::DataStore (IProxyDict& pool)
32  : m_pool (pool),
33  m_storeMap(),
34  m_keyMap(KeyMap_t::Updater_t()),
35  m_storeID(StoreID::UNKNOWN), m_t2p(),
36  m_noAudSvc(0), m_pSvcLoc(0)
37 {
38  setSvcLoc().ignore();
39 }
40 
41 //Destructor
43 {
44  clearStore(false, true, nullptr);
45 }
46 
48  StatusCode sc(StatusCode::FAILURE);
49  m_pSvcLoc = Gaudi::svcLocator( );
50  if (!m_pSvcLoc) std::cout<<"DataStore::setSvcLoc: WARNING svcLocator not found! "<<std::endl;
51  return sc;
52 }
53 
55  if (!m_pSGAudSvc) {
56  //try once to get the service
57  if (!m_noAudSvc) {
58  const bool DONOTCREATE(false);
59  m_pSGAudSvc = m_pSvcLoc->service("SGAudSvc", DONOTCREATE);
60  m_noAudSvc = not m_pSGAudSvc.isValid();
61  }
62  }
63  return;
64 }
65 
66 
68 void DataStore::clearStore(bool force, bool hard, MsgStream* /*pmlog*/)
69 {
72 
79  std::unordered_set<DataProxy*> saved;
80 
86  for (size_t i = 0; i < m_proxies.size(); ) {
88  if (ATH_UNLIKELY (dp->requestRelease (force, hard))) {
89  if (removeProxyImpl (dp, i).isFailure()) {
90  ++i;
91  }
92  }
93  else {
94  saved.insert (dp);
95  ++i;
96  }
97  }
98 
99  KeyMap_t newMap (KeyMap_t::Updater_t(), m_keyMap.capacity());
100  {
101  auto lock = newMap.lock();
102  auto ctx = KeyMap_t::Updater_t::defaultContext();
103  for (auto p : m_keyMap) {
104  if (saved.count (p.second)) {
105  newMap.emplace (lock, p.first, p.second, ctx);
106  }
107  }
108  }
109  m_keyMap.swap (newMap);
110 
111  // clear T2PMap
112  m_t2p.clear();
113 }
114 
116 // access all the keys associated with an object:
117 //
118 void DataStore::keys(const CLID& id, std::vector<std::string>& vkeys,
119  bool includeAlias, bool onlyValid)
120 {
121  vkeys.clear();
122  for (const ProxyMap::value_type& p : m_storeMap[id]) {
123  bool includeProxy(true);
124  if (onlyValid) includeProxy=p.second->isValid();
125  if (includeAlias) {
126  if (includeProxy) vkeys.push_back(p.first);
127  }
128  else {
129  if (p.first == p.second->name() && includeProxy)
130  vkeys.push_back(p.first);
131  }
132  }
133 }
134 
136 //---------------------------------------------------------------//
137 // record the proxy in StoreGate
138 StatusCode
140 {
141  if (!dp) {
142  return StatusCode::FAILURE;
143  }
144 
147  bool primary = false;
148  if (dp->store() == nullptr) {
149  m_proxies.push_back (dp);
150  primary = true;
151  }
152 
153  if (id == 0 && dp->clID() == 0 && dp->sgkey() != 0) {
154  // Handle a dummied proxy.
155  m_keyMap.emplace (dp->sgkey(), dp);
156  }
157  else {
158  ProxyMap& pmap = m_storeMap[id];
159 
160  // Set the primary key.
161  sgkey_t primary_sgkey = m_pool.stringToKey (dp->name(), dp->clID());
162  sgkey_t sgkey = primary_sgkey;
163  if (id != dp->clID()) {
164  sgkey = m_pool.stringToKey (dp->name(), id);
165  }
166  if (dp->sgkey() == 0) {
167  dp->setSGKey (sgkey);
168  }
169 
170  if (!m_keyMap.emplace (sgkey, dp).second) {
171  if (primary) {
172  m_proxies.pop_back();
173  }
174  return StatusCode::FAILURE;
175  }
176 
177  pmap.insert(ProxyMap::value_type(dp->name(), dp));
178  }
179 
180  // Note : No checking if proxy already exists in store because it
181  // is already checked in StoreGateSvc.
182  // if (pmap.find(dp->name()) == pmap.end()) {
183  dp->addRef(); // The store now owns this
184  dp->setT2p(&m_t2p);
185  dp->setStore(&m_pool);
186 
187  return StatusCode::SUCCESS;
188 }
189 
190 
192 //---------------------------------------------------------------//
193 // if Proxy is a resettable proxy only then reset it, otherwise
194 // delete it and remove from proxy map.
196 DataStore::removeProxy(DataProxy* proxy, bool forceRemove, bool hard)
197 {
198  if (!proxy) {
199  return StatusCode::FAILURE;
200  }
201 
202  if (!forceRemove && proxy->isResetOnly()) {
203  // A reset-only proxy. Don't remove it.
204  proxy->reset (hard);
205  return StatusCode::SUCCESS;
206  }
207 
208  // First remove from m_keyMap.
209  // We may fail to find the entry if this is a key that has been versioned.
210  // E.g., we add aVersObj. Call this DP1.
211  // Then we add a new version of it. Call this DP2.
212  // The version logic will add the alias ';00;aVersObj' to DP1.
213  // It will also then add the alias `aVersObj' to DP2.
214  // This will overwrite the entries for DP1 in pmap and m_keyMap.
215  // If we then clear and DP2 is removed first, then the m_keyMap entry
216  // for DP1's primary key will be gone.
217  // FIXME: Should just remove the versioned key code ... it's anyway
218  // not compatible with MT.
219  removeFromKeyMap (proxy).ignore();
220 
221  // Then remove from the m_storeMap and release the proxy.
222  auto it = std::find (m_proxies.begin(), m_proxies.end(), proxy);
223  if (it == m_proxies.end()) {
224  return StatusCode::FAILURE;
225  }
226  return removeProxyImpl (proxy, it - m_proxies.begin());
227 }
228 
229 
235 {
236  SG::DataProxy::AliasCont_t alias_set = proxy->alias();
237  std::string name = proxy->name();
238 
239  for (CLID symclid : proxy->transientID())
240  {
241  sgkey_t sgkey = m_pool.stringToKey (name, symclid);
242  m_keyMap.erase (sgkey);
243 
244  for (const std::string& alias : alias_set) {
245  m_keyMap.erase (m_pool.stringToKey (alias, symclid));
246  }
247  }
248 
249  return StatusCode::SUCCESS;
250 }
251 
252 
263 {
264  proxy->setStore (nullptr);
265 
266  std::string name = proxy->name();
267  CLID clid = proxy->clID();
268  SG::DataProxy::AliasCont_t alias_set = proxy->alias();
269 
270  // nb. This has to be here, not just before the loop below,
271  // as the proxy may be deleted in the meantime.
273 
274  StoreIterator storeIter = m_storeMap.find(clid);
275  if (storeIter != m_storeMap.end()) {
276  ProxyMap& pmap = storeIter->second;
277 
278  // first remove the alias key:
279  SG::DataProxy::AliasCont_t alias_set = proxy->alias();
280  for (const std::string& alias : alias_set) {
281  if (1 == pmap.erase(alias)) proxy->release();
282  }
283 
284  // Remove primary entry.
285  if (1 == pmap.erase(name)) {
286  proxy->release();
287  }
288  }
289  else {
290  // A dummy proxy.
291  proxy->release();
292  }
293 
294  // Remove all symlinks too.
295  for (CLID symclid : clids)
296  {
297  if (clid == symclid) continue;
298  storeIter = m_storeMap.find(symclid);
299  if (storeIter != m_storeMap.end()) {
300  ProxyMap& pmap = storeIter->second;
301  SG::ProxyIterator it = pmap.find (name);
302  if (it != pmap.end() && it->second == proxy) {
303  storeIter->second.erase (it);
304  proxy->release();
305  }
306 
307  for (const std::string& alias : alias_set) {
308  if (1 == pmap.erase (alias)) proxy->release();
309  }
310  }
311  } //symlinks loop
312 
313  if (index != -1 && !m_proxies.empty()) {
314  // Remove the proxy from m_proxies. If it's not at the end, then
315  // move the proxy at the end to this proxy's index (and update the
316  // index for the other proxy stored in m_keyMap).
317  if (index != (int)m_proxies.size() - 1) {
318  m_proxies[index] = m_proxies.back();
319  }
320  m_proxies.pop_back();
321  }
322 
323  return StatusCode::SUCCESS;
324 }
325 
327 //---------------------------------------------------------------//
328 // record the symlink in StoreGate
329 StatusCode
331 {
332  // Make sure the symlink doesn't already exist.
333  DataProxy* exist = proxy_exact (linkid, dp->name());
334  if (exist == dp) {
335  // Entry already exists pointing at the desired proxy.
336  return StatusCode::SUCCESS;
337  }
338  else if (!exist) {
339  dp->setTransientID(linkid);
340  return addToStore(linkid, dp);
341  }
342 
343  // Already an existing proxy.
344  if (exist->isValidObject()) {
345  // And it's set to something. Ok if it's the same DataObject.
346  // Otherwise fail.
347  if (exist->object() == dp->object()) {
348  dp->setTransientID(linkid);
349  return StatusCode::SUCCESS;
350  }
351  return StatusCode::FAILURE;
352  }
353  if (!dp->object()) {
354  return StatusCode::FAILURE;
355  }
356  if (exist->loader()) {
357  return StatusCode::FAILURE;
358  }
359 
360  // The existing proxy is not set to anything, and it doesn't have a loader.
361  // It may have been created by a forward-declared link to a base class.
362  // In that case, set the existing proxy to also point at the same DataObject.
363  const SG::BaseInfoBase* bib = SG::BaseInfoBase::find (dp->clID());
364  if (bib && bib->is_base (exist->clID())) {
365  dp->setTransientID(linkid);
366  exist->setObject (dp->object(), false);
367  return StatusCode::SUCCESS;
368  }
369 
370  // Entry already exists pointing at another proxy.
371  // Don't change the existing entry.
372  return StatusCode::FAILURE;
373 }
374 //---------------------------------------------------------------//
375 // record the alias in StoreGate
377 DataStore::addAlias(const std::string& aliasKey, DataProxy* dp)
378 {
379  for (CLID clid : dp->transientID()) {
380  // locate proxy map and add alias to proxymap
381  ProxyMap& pmap = m_storeMap[clid];
382 
383  // check if another proxy for the same type caries the same alias.
384  // if yes, then remove that alias from that proxy and establish the
385  // alias in the new proxy.
386  // pmap.insert will overwrite, associate alias with new proxy.
387  ConstProxyIterator p_iter = pmap.find(aliasKey);
388  if (p_iter != pmap.end() && dp->clID() == p_iter->second->clID()) {
389  if (dp->name() == p_iter->second->name()) return StatusCode::SUCCESS;
390  p_iter->second->removeAlias(aliasKey);
391  p_iter->second->release();
392  }
393  dp->addRef();
394  pmap[aliasKey] = dp;
395  m_keyMap.emplace (m_pool.stringToKey (aliasKey, clid), dp);
396  }
397 
398  // set alias in proxy
399  dp->setAlias(aliasKey);
400 
401  return StatusCode::SUCCESS;
402 }
403 //---------------------------------------------------------------//
404 // Count instances of TYPE in store
405 int DataStore::typeCount(const CLID& id) const
406 {
407  ConstStoreIterator storeIter = m_storeMap.find(id);
408  if (storeIter == m_storeMap.end()) return 0;
409  return (storeIter->second).size();
410 }
411 
412 //---------------------------------------------------------------//
413 // Return proxy for a given Transient Address
415 {
416  return proxy(tAddr->clID(), tAddr->name());
417 }
418 
419 // Return proxy for a given Transient ID (TYPE and KEY)
420 DataProxy* DataStore::proxy(const CLID& id, const std::string& key) const
421 {
422 
423  // The logic here: if a key is specified, we locate it.
424  // If we don't find it and the default key (DEFAULTKEY) is specified,
425  // then we return any existing proxy for this type as long as there
426  // is exactly one, not counting aliases. More than one would be ambiguous
427 
428  ConstStoreIterator siter = m_storeMap.find(id);
429  DataProxy *p(0);
430  if (siter != m_storeMap.end())
431  {
432  const ProxyMap& pmap = siter->second;
433  ConstProxyIterator p_iter = pmap.find(key);
434  if (p_iter != pmap.end()) {
435  p=p_iter->second;
436 
437  } else if (key == SG::DEFAULTKEY && !pmap.empty()) {
438  // we did not find the object using key.
439  // Now check for default object.
440  // If there are multiple entries, they must all be
441  // referring to the same proxy (aliases).
442  for (const auto& ent : pmap) {
443  if (!p) {
444  p = ent.second;
445  }
446  else if (p != ent.second) {
447  p = nullptr;
448  break;
449  }
450  }
451 
452  // If that didn't work, try it again, considering only objects that
453  // are exactly the type being requested.
454  if (!p) {
455  for (const auto& ent : pmap) {
456  if (ent.second->clID() == id) {
457  if (!p) {
458  p = ent.second;
459  }
460  else if (p != ent.second) {
461  p = nullptr;
462  break;
463  }
464  }
465  }
466  }
467  }
468  else {
469  // Ok since access to DataStore is serialized by StoreGate.
470  DataStore* nc_store ATLAS_THREAD_SAFE = const_cast<DataStore*> (this);
471  p = nc_store->findDummy (id, key);
472  }
473  }
474  else {
475  // Ok since access to DataStore is serialized by StoreGate.
476  DataStore* nc_store ATLAS_THREAD_SAFE = const_cast<DataStore*> (this);
477  p = nc_store->findDummy (id, key);
478  }
479 
480  if (p && m_pSGAudSvc)
481  m_pSGAudSvc->SGAudit(p->name(), id, 0, m_storeID);
482 
483  return p;
484 }
485 
486 
505 DataProxy* DataStore::findDummy (CLID id, const std::string& key)
506 {
509  if (p) {
510  p->setID (id, key);
511  ProxyMap& pmap = m_storeMap[id];
512  if (!pmap.insert(ProxyMap::value_type(key, p)).second) {
513  // This shouldn't happen.
514  DataProxy* p2 = pmap[key];
515  throw SG::ExcProxyCollision (id, key, p2->clID(), p2->name());
516  }
517  }
518  return p;
519 }
520 
521 
525 {
526  if (m_pSGAudSvc) {
527  CLID clid;
528  const std::string* strkey = m_pool.keyToString (sgkey, clid);
529  if (strkey)
530  m_pSGAudSvc->SGAudit(*strkey, clid, 0, m_storeID);
531  }
532  KeyMap_t::const_iterator i = m_keyMap.find (sgkey);
533  if (i != m_keyMap.end())
534  return i->second;
535  return 0;
536 }
537 
538 
544  std::recursive_mutex& mutex) const
545 {
546  if (m_pSGAudSvc) {
547  std::unique_lock lock (mutex);
548  CLID clid;
549  const std::string* strkey = m_pool.keyToString (sgkey, clid);
550  if (strkey)
551  m_pSGAudSvc->SGAudit(*strkey, clid, 0, m_storeID);
552  }
553  KeyMap_t::const_iterator i = m_keyMap.find (sgkey);
554  if (i != m_keyMap.end())
555  return i->second;
556  return 0;
557 }
558 
559 
563  const std::string& key) const
564 {
565  // Suppress warning here about calling to a nonconst method
566  // of m_pool. Ok since all callers here must own the store lock.
568  return proxy_exact (pool_nc.stringToKey (key, id));
569 }
570 
571 
572 //---------------------------------------------------------------//
573 // Return an iterator over proxies for a given CLID:
575  ConstProxyIterator& pe) const
576 {
577  static const ProxyMap emptyMap;
578  StatusCode sc(StatusCode::FAILURE);
579 
580  ConstStoreIterator storeIter = m_storeMap.find(id);
581  if (storeIter != m_storeMap.end())
582  {
583  const ProxyMap& pmap = storeIter->second;
584  pf = pmap.begin();
585  pe = pmap.end();
586  if (pmap.size() > 0) sc = StatusCode::SUCCESS;
587  } else {
588  //keep valgrind happy
589  pf = emptyMap.end();
590  pe = emptyMap.end();
591  }
592  return sc;
593 }
594 //---------------------------------------------------------------//
595 // Return an iterator over the Store Map
597  ConstStoreIterator& te) const
598 {
599  tf = m_storeMap.begin();
600  te = m_storeMap.end();
601  return StatusCode::SUCCESS;
602 }
603 //---------------------------------------------------------------//
604 // locate Persistent Representation of a Transient Object
605 //
606 DataProxy* DataStore::locatePersistent(const void* const pTransient) const
607 {
608  return m_t2p.locatePersistent(pTransient);
609 }
610 
613 DataStore::t2pRegister(const void* const pTrans, DataProxy* const pPers)
614 {
615  std::string name=pPers->name();
616  int i=name.find('/', 0);
617  name=name.erase(0,i+1);
618 
619  if (doAudit()) m_pSGAudSvc->SGAudit(name, pPers->clID(), 1, m_storeID);
620 
621  return (m_t2p.t2pRegister(pTrans, pPers)) ?
622  StatusCode::SUCCESS :
623  StatusCode::FAILURE;
624 }
625 
626 
627 const std::vector<DataProxy*>& DataStore::proxies() const
628 {
629  return m_proxies;
630 }
631 
SG::ProxyIterator
ProxyMap::iterator ProxyIterator
Definition: ProxyMap.h:27
python.StoreID.UNKNOWN
int UNKNOWN
Definition: StoreID.py:16
SG::DataStore::typeCount
int typeCount(const CLID &id) const
Count number of object of a given type in store.
Definition: Control/SGTools/src/DataStore.cxx:405
common.sgkey
def sgkey(tool)
Definition: common.py:1028
exceptions.h
Exceptions that can be thrown by SGTools.
TileDCSDataPlotter.dp
dp
Definition: TileDCSDataPlotter.py:840
SG::DataStore::t2pRegister
StatusCode t2pRegister(const void *const pTrans, DataProxy *const pPers)
methods to query the T2PMap:
Definition: Control/SGTools/src/DataStore.cxx:613
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
SG::DataStore::~DataStore
virtual ~DataStore()
Definition: Control/SGTools/src/DataStore.cxx:42
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
calibdata.force
bool force
Definition: calibdata.py:19
SG::T2pMap::locatePersistent
DataProxy * locatePersistent(const void *const pTransient) const
Definition: T2pMap.h:42
IStringPool::stringToKey
virtual sgkey_t stringToKey(const std::string &str, CLID clid)=0
Find the key for a string/CLID pair.
index
Definition: index.py:1
SG::DataStore::m_t2p
T2pMap m_t2p
Definition: Control/SGTools/SGTools/DataStore.h:201
BeamSpot::mutex
std::mutex mutex
Definition: InDetBeamSpotVertex.cxx:18
DataStore.h
pool
pool namespace
Definition: libname.h:15
SG::DataStore::m_keyMap
KeyMap_t m_keyMap
Definition: Control/SGTools/SGTools/DataStore.h:194
skel.it
it
Definition: skel.GENtoEVGEN.py:396
SG::DataStore::m_storeMap
StoreMap m_storeMap
Maps locating proxies by clid/key.
Definition: Control/SGTools/SGTools/DataStore.h:183
SG::TransientAddress
Definition: TransientAddress.h:32
SG::DataStore::addToStore
virtual StatusCode addToStore(const CLID &id, DataProxy *proxy)
add proxy to store.
Definition: Control/SGTools/src/DataStore.cxx:139
SG::DataStore::ConstStoreIterator
StoreMap::const_iterator ConstStoreIterator
Definition: Control/SGTools/SGTools/DataStore.h:81
SG::DataStore::clearStore
void clearStore(bool force, bool hard, MsgStream *pmlog)
If HARD is true, then the bound objects should also clear any data that depends on the identity of th...
Definition: Control/SGTools/src/DataStore.cxx:68
ATH_UNLIKELY
#define ATH_UNLIKELY(x)
Definition: AthUnlikelyMacros.h:17
SG::DataStore::proxy
virtual DataProxy * proxy(const TransientAddress *tAddr) const
return proxy for a given type/key pair if key is empty returns the default proxy (currently last regi...
Definition: Control/SGTools/src/DataStore.cxx:414
LArG4AODNtuplePlotter.pe
pe
Definition: LArG4AODNtuplePlotter.py:116
IProxyDict
A proxy dictionary.
Definition: AthenaKernel/AthenaKernel/IProxyDict.h:47
SG::DataProxy::CLIDCont_t
TransientAddress::TransientClidSet CLIDCont_t
Definition: DataProxy.h:54
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SG::DataStore::removeFromKeyMap
StatusCode removeFromKeyMap(DataProxy *proxy)
Remove a proxy from m_keyMap.
Definition: Control/SGTools/src/DataStore.cxx:234
SG::DataProxy::setStore
void setStore(IProxyDict *store)
Set the store of which we're a part.
SG::DataStore::doAudit
bool doAudit()
Definition: Control/SGTools/SGTools/DataStore.h:206
SG::ProxyMap
std::map< std::string, DataProxy * > ProxyMap
Definition: ProxyMap.h:24
SG::DataStore::StoreIterator
StoreMap::iterator StoreIterator
Definition: Control/SGTools/SGTools/DataStore.h:80
SG::TransientAddress::name
const std::string & name() const
Get the primary (hashed) SG key.
Definition: TransientAddress.h:208
AthUnlikelyMacros.h
SG::DataStore::proxy_exact
SG::DataProxy * proxy_exact(sgkey_t sgkey) const
get proxy with given key.
Definition: Control/SGTools/src/DataStore.cxx:524
SG::DataStore::setSGAudSvc
void setSGAudSvc()
Definition: Control/SGTools/src/DataStore.cxx:54
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
StateLessPT_NewConfig.primary
primary
Definition: StateLessPT_NewConfig.py:228
WriteCellNoiseToCool.exist
exist
Definition: WriteCellNoiseToCool.py:543
IStringPool.h
Abstract interface for looking up strings/CLIDs in a pool.
lumiFormat.i
int i
Definition: lumiFormat.py:85
SG::DataStore::m_proxies
std::vector< DataProxy * > m_proxies
All proxies managed by this store.
Definition: Control/SGTools/SGTools/DataStore.h:180
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::DataStore::findDummy
DataProxy * findDummy(CLID id, const std::string &key)
Look for (and convert) a matching dummy proxy.
Definition: Control/SGTools/src/DataStore.cxx:505
SG::DataProxy::alias
AliasCont_t alias() const
access set of proxy aliases Returns a COPY of the alias set.
SG::TransientAddress::clID
CLID clID() const
Retrieve string key:
Definition: TransientAddress.h:201
SG::DataStore::m_pool
IProxyDict & m_pool
The string pool associated with this store.
Definition: Control/SGTools/SGTools/DataStore.h:176
COOLRates.alias
alias
Definition: COOLRates.py:1172
SG::DataStore::m_pSGAudSvc
SmartIF< ISGAudSvc > m_pSGAudSvc
Definition: Control/SGTools/SGTools/DataStore.h:204
SG::T2pMap::t2pRegister
bool t2pRegister(const void *const pTrans, DataProxy *const pPers)
Definition: T2pMap.h:34
SG::DataStore::m_pSvcLoc
ISvcLocator * m_pSvcLoc
Definition: Control/SGTools/SGTools/DataStore.h:211
SG::DataStore::addSymLink
StatusCode addSymLink(const CLID &linkid, DataProxy *proxy)
add symlink to store:
Definition: Control/SGTools/src/DataStore.cxx:330
SG::DataStore::sgkey_t
IStringPool::sgkey_t sgkey_t
Definition: Control/SGTools/SGTools/DataStore.h:78
StoreID
defines an enum used by address providers to decide what kind of StoreGateSvc they are providing addr...
Definition: StoreID.h:18
SG::T2pMap::clear
void clear()
Definition: T2pMap.h:53
SG::DEFAULTKEY
const std::string DEFAULTKEY
Definition: DefaultKey.h:12
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
SG::DataProxy::clID
CLID clID() const
Retrieve clid.
SG::DataProxy::release
virtual unsigned long release() override final
release reference to object
Definition: DataProxy.cxx:320
SG::DataStore::removeProxyImpl
StatusCode removeProxyImpl(DataProxy *proxy, int index)
Helper for removing a proxy.
Definition: Control/SGTools/src/DataStore.cxx:262
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:227
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::DataStore::keys
void keys(const CLID &id, std::vector< std::string > &vkeys, bool includeAlias, bool onlyValid)
Definition: Control/SGTools/src/DataStore.cxx:118
SG::DataStore::setSvcLoc
StatusCode setSvcLoc()
Definition: Control/SGTools/src/DataStore.cxx:47
SG::DataProxy::name
virtual const name_type & name() const override final
Retrieve data object key == string.
SG::DataStore::locatePersistent
DataProxy * locatePersistent(const void *const pTransient) const
locate the persistent (proxy) for a given T* (void*):
Definition: Control/SGTools/src/DataStore.cxx:606
SG::DataStore::m_storeID
StoreID::type m_storeID
Definition: Control/SGTools/SGTools/DataStore.h:196
DeMoScan.index
string index
Definition: DeMoScan.py:364
SG::DataProxy::reset
void reset(bool hard=false)
Other methods of DataProxy (not in Interface IRegistry):
Definition: DataProxy.cxx:240
SimpleUpdater.h
Simple (non-deleting) Updater implementation.
SG::DataProxy::transientID
bool transientID(CLID id) const
return the list of transient IDs (primary or symLinked):
python.output.AtlRunQueryRoot.pf
pf
Definition: AtlRunQueryRoot.py:988
SG::DataStore
Hold DataProxy instances associated with a store.
Definition: Control/SGTools/SGTools/DataStore.h:74
SG::DataStore::proxies
const std::vector< DataProxy * > & proxies() const
All proxies managed by this store.
Definition: Control/SGTools/src/DataStore.cxx:627
SG::DataStore::addAlias
StatusCode addAlias(const std::string &aliasKey, DataProxy *proxy)
add alias to store
Definition: Control/SGTools/src/DataStore.cxx:377
ISGAudSvc.h
IStringPool::keyToString
virtual const std::string * keyToString(sgkey_t key) const =0
Find the string corresponding to a given key.
SG::BaseInfoBase
The non-template portion of the BaseInfo implementation.
Definition: Control/AthenaKernel/AthenaKernel/BaseInfo.h:451
SG::DataStore::KeyMap_t
CxxUtils::ConcurrentMap< sgkey_t, DataProxy *, CxxUtils::SimpleUpdater, SGKeyHash, SGKeyEqual, 0, s_nullval > KeyMap_t
Definition: Control/SGTools/SGTools/DataStore.h:193
SG::DataStore::pRange
StatusCode pRange(const CLID &id, SG::ConstProxyIterator &f, SG::ConstProxyIterator &e) const
Return an iterator over proxy for a given CLID:
Definition: Control/SGTools/src/DataStore.cxx:574
SG::DataStore::removeProxy
StatusCode removeProxy(DataProxy *proxy, bool forceRemove, bool hard)
remove proxy from store, unless proxy is reset only.
Definition: Control/SGTools/src/DataStore.cxx:196
SG::DataProxy::isResetOnly
bool isResetOnly() const
Check reset only:
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
checker_macros.h
Define macros for attributes used to control the static checker.
SG::DataProxy
Definition: DataProxy.h:45
SG::DataStore::tRange
StatusCode tRange(ConstStoreIterator &f, ConstStoreIterator &e) const
Return an iterator over the StoreMap:
Definition: Control/SGTools/src/DataStore.cxx:596
SG::DataStore::proxy_exact_unlocked
SG::DataProxy * proxy_exact_unlocked(sgkey_t sgkey, std::recursive_mutex &mutex) const
Like proxy_exact, but intended to be called without holding the store lock.
Definition: Control/SGTools/src/DataStore.cxx:543
SG::DataStore::m_noAudSvc
bool m_noAudSvc
Definition: Control/SGTools/SGTools/DataStore.h:205
SG::DataProxy::AliasCont_t
TransientAddress::TransientAliasSet AliasCont_t
Definition: DataProxy.h:55
SG::ExcProxyCollision
Exception — Proxy collision for clid/key.
Definition: Control/SGTools/SGTools/exceptions.h:80
SG::ConstProxyIterator
ProxyMap::const_iterator ConstProxyIterator
Definition: ProxyMap.h:28
ConcurrentPtrSet.h
A set of pointers, alowing concurrent, lockless reads.
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
DataProxy.h
SG::BaseInfoBase::is_base
bool is_base(CLID clid) const
Return true if clid is the ID of a class that is known to be a base of T.
Definition: BaseInfo.cxx:344