ATLAS Offline Software
SGImplSvc.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 #undef DEBUG_SGIMPL
6 
7 #include <algorithm>
8 #include <cassert>
9 #include <cstdio>
10 #include <iostream>
11 #include <functional>
12 #include <format>
13 #include <string>
14 #include <unordered_map>
15 
16 #include <sstream>
17 #include <fstream>
18 #include <iomanip>
19 
24 #include "AthenaKernel/IIOVSvc.h"
27 #include "AthenaKernel/StoreID.h"
28 #include "GaudiKernel/IClassIDSvc.h"
29 #include "GaudiKernel/IHistorySvc.h"
30 #include "GaudiKernel/ISvcLocator.h"
31 #include "GaudiKernel/IConversionSvc.h"
32 #include "GaudiKernel/Incident.h"
33 #include "GaudiKernel/IOpaqueAddress.h"
34 #include "GaudiKernel/MsgStream.h"
35 #include "GaudiKernel/StatusCode.h"
36 #include "GaudiKernel/DataHistory.h"
39 #include "SGTools/DataProxy.h"
40 #include "SGTools/DataStore.h"
41 #include "SGTools/StringPool.h"
43 #include "SGTools/SGVersionedKey.h"
48 
49 // StoreGateSvc. must come before SGImplSvc.h
50 #include "StoreGate/StoreGateSvc.h"
52 #include "SGTools/DataStore.h"
53 
54 using std::setw;
55 using std::hex;
56 using std::dec;
57 using std::endl;
58 using std::ends;
59 using std::pair;
60 using std::string;
61 using std::vector;
62 
63 using SG::DataProxy;
64 using SG::DataStore;
66 
67 // Helpers for debug formatting
68 // std::print implementation to be replaced when C++ 23 is available
69 namespace dbg {
70 template <class... Args> void print(std::FILE* stream, std::format_string<Args...> fmt, Args&&... args) {
71  std::fputs(std::format(fmt, std::forward<Args>(args)...), stream);
72 }
73 
74 template <class T> void* ptr(T* p) { return static_cast<void*>(p); }
75 }
76 
78 // Remapping implementation.
79 
80 
81 namespace SG {
82 
83 
84  struct RemapImpl
85  {
87 
88  struct remap_t {
90  off_t index_offset;
91  };
94  };
95 
96 
97 } // namespace SG
98 
99 
102 SGImplSvc::SGImplSvc(const string& name,ISvcLocator* svc)
103  : Service(name, svc),
104  m_pCLIDSvc("ClassIDSvc", name),
105  m_pDataLoader("EventPersistencySvc", name),
106  m_pPPSHandle("ProxyProviderSvc", name),
107  m_pPPS(nullptr),
108  m_pHistorySvc("HistorySvc", name),
109  m_pStore(new DataStore(*this)),
110  m_pIncSvc("IncidentSvc", name),
111  m_DumpStore(false),
112  m_ActivateHistory(false),
113  m_DumpArena(false),
114  m_pIOVSvc("IOVSvc", name),
115  m_storeLoaded(false),
116  m_remap_impl (new SG::RemapImpl),
117  m_arena (name),
118  m_slotNumber(-1),
119  m_numSlots(1)
120 {
121  //our properties
122  declareProperty("ProxyProviderSvc", m_pPPSHandle);
123  declareProperty("Dump", m_DumpStore);
124  declareProperty("ActivateHistory", m_ActivateHistory);
125  declareProperty("DumpArena", m_DumpArena);
126  //StoreGateSvc properties
127  declareProperty("IncidentSvc", m_pIncSvc);
128  //add handler for Service base class property
129  m_outputLevel.declareUpdateHandler(&SGImplSvc::msg_update_handler, this);
130 
132  header->addArena (&m_arena);
133 }
134 
135 
139  header->delArena (&m_arena);
140 
141  delete m_pStore;
142  delete m_remap_impl;
143 }
144 
148 
149  verbose() << "Initializing " << name() << endmsg;
150 
152 
153  if (!m_pStore)
154  m_pStore = new DataStore (*this);
155  if (!m_remap_impl)
157 
158  //properties accessible from now on
159 
161  // If this is the default event store (StoreGateSvc), then declare
162  // our arena as the default for memory allocations.
163  if (this->storeID() == StoreID::EVENT_STORE) {
166  }
167  // set up the incident service:
168  if (!(m_pIncSvc.retrieve()).isSuccess()) {
169  error() << "Could not locate IncidentSvc "
170  << endmsg;
171  return StatusCode::FAILURE;
172  }
173 
174  // We explicitly do not retrieve m_pIOVSvc and rely on retrieval
175  // on first use to avoid an initialization loop here.
176 
177  CHECK( m_pDataLoader.retrieve() );
178  CHECK( m_pCLIDSvc.retrieve() );
179 
180  if (!m_pPPSHandle.empty()) {
181  CHECK( m_pPPSHandle.retrieve() );
182  m_pPPS = &*m_pPPSHandle;
183  }
184 
185  if ( m_pPPS && (m_pPPS->preLoadProxies(*m_pStore)).isFailure() )
186  {
187  SG_MSG_DEBUG(" Failed to preLoad proxies");
188  return StatusCode::FAILURE;
189  }
190 
191  // Get hold of History Service
192  if (m_ActivateHistory) {
193  CHECK( m_pHistorySvc.retrieve() );
194  }
195 
196  return StatusCode::SUCCESS;
197 }
200 
201  verbose() << "Start " << name() << endmsg;
202  /*
203  // This will need regFcn clients to be updated first.
204  if ( 0 == m_pPPS || (m_pPPS->preLoadProxies(*m_pStore)).isFailure() ) {
205  debug() << " Failed to preLoad proxies"
206  << endmsg;
207  return StatusCode::FAILURE;
208  }
209  */
210 
211  return StatusCode::SUCCESS;
212 }
215 
216  verbose() << "Stop " << name() << endmsg;
217  //HACK ALERT: ID event store objects refer to det store objects
218  //by setting an ad-hoc priority for event store(s) we make sure they are finalized and hence cleared first
219  // see e.g. https://savannah.cern.ch/bugs/index.php?99993
220  if (store()->storeID() == StoreID::EVENT_STORE) {
221  ISvcManager* pISM(dynamic_cast<ISvcManager*>(serviceLocator().get()));
222  if (!pISM)
223  return StatusCode::FAILURE;
224  pISM->setPriority(name(), pISM->getPriority(name())+1).ignore();
225  verbose() << "stop: setting service priority to " << pISM->getPriority(name())
226  << " so that event stores get finalized and cleared before other stores" <<endmsg;
227  }
228  return StatusCode::SUCCESS;
229 }
230 
232 void SGImplSvc::handle(const Incident &inc) {
233 
234  if (inc.type() == "EndEvent") {
235  if (m_DumpStore) {
236  SG_MSG_DEBUG("Dumping StoreGate Contents");
237  info() << '\n' << dump() << endl
238  << endmsg;
239  }
240  }
241 }
242 
244  lock_t lock (m_mutex);
245  StatusCode sc(StatusCode::SUCCESS);
246  //FIXME this should probably be dealt with by the providers
247  if (0 != m_pPPS && !m_storeLoaded) {
248  m_storeLoaded = true;
250 #ifdef DEBUG_SGIMPL
251  dbg::print(stderr, "SGImplSvc::loadEventProxies() LOADED PROXIES on {}\n", name());
252  }
253  else {
254  dbg::print(stderr, "SGImplSvc::loadEventProxies() PROXIES ALREADY LOADED on {}\n", name());
255 #endif
256  }
257  return sc;
258 }
259 
261 // Create a key for a type (used if the client has not specified a key)
262 string SGImplSvc::createKey(const CLID& id)
263 {
264  return std::to_string(m_pStore->typeCount(id) + 1);
265 }
267 // clear store
269 {
270 #ifdef DEBUG_SGIMPL
271  dbg::print(stderr, "SGImplSvc::clearStore(forceRemove={}) on {}\n", forceRemove, name());
272 #endif
273  {
274  if (m_DumpArena) {
275  std::ostringstream s;
276  m_arena.report(s);
277  info() << "Report for Arena: " << m_arena.name() << '\n'
278  << s.str() << endmsg;
279  }
280  }
281  {
282  lock_t lock (m_mutex);
283  emptyTrash();
284  for (auto& p : m_newBoundHandles)
285  p.second.clear();
286  assert(m_pStore);
287  debug() << "Clearing store with forceRemove="
288  << forceRemove << endmsg;
289  bool hard_reset = (m_numSlots > 1);
290  m_pStore->clearStore(forceRemove, hard_reset, &msgStream(MSG::DEBUG));
291  m_storeLoaded=false; //FIXME hack needed by loadEventProxies
292  }
293  {
294  lock_t remap_lock (m_remapMutex);
295  m_remap_impl->m_remaps.clear();
296  m_arena.reset();
297  }
298 
299  return StatusCode::SUCCESS;
300 }
304  verbose() << "Finalizing " << name() << endmsg ;
305 
306  // Incident service may not work in finalize.
307  // Clear this, so that we won't try to send an incident from clearStore.
308  (m_pIncSvc.release()).ignore();
309 
310  const bool FORCEREMOVE(true);
311  clearStore(FORCEREMOVE).ignore();
312 
314  delete m_pStore;
315  m_pStore = nullptr;
316  delete m_remap_impl;
317  m_remap_impl = 0;
318  m_arena.erase();
319 
320  return Service::finalize();
321 }
325  verbose() << "Reinitializing " << name() << endmsg ;
326  const bool FORCEREMOVE(true);
327  clearStore(FORCEREMOVE).ignore();
328  //not in v20r2p2! return Service::reinitialize();
329  return StatusCode::SUCCESS;
330 }
331 
332 const InterfaceID&
334  static const InterfaceID IID("SGImplSvc", 1, 0);
335  return IID;
336 }
337 
338 // Query the interfaces.
339 // Input: riid, Requested interface ID
340 // ppvInterface, Pointer to requested interface
341 // Return: StatusCode indicating SUCCESS or FAILURE.
342 // N.B. Don't forget to release the interface after use!!!
343 StatusCode SGImplSvc::queryInterface(const InterfaceID& riid, void** ppvInterface)
344 {
345  if ( IProxyDict::interfaceID().versionMatch(riid) ) {
346  *ppvInterface = (IProxyDict*)this;
347  }
348  else if ( IProxyDict::interfaceID().versionMatch(riid) ) {
349  *ppvInterface = (IProxyDict*)this;
350  }
351  else if ( IHiveStoreMgr::interfaceID().versionMatch(riid) ) {
352  *ppvInterface = (IHiveStoreMgr*)this;
353  }
354  else if ( interfaceID().versionMatch(riid) ) {
355  // In principle this should be cast to ISGImplSvc*. However, there
356  // is an anomaly in that existing clients are using the concrete StoreGate
357  // interface instead of an abstract ISGImplSvc interface.
358  *ppvInterface = (SGImplSvc*)this;
359  } else {
360  // Interface is not directly available: try out a base class
361  return Service::queryInterface(riid, ppvInterface);
362  }
363  addRef();
364  return StatusCode::SUCCESS;
365 }
366 
369 // add proxy (with IOpaqueAddress that will later be retrieved from P)
371 StatusCode SGImplSvc::recordAddress(const std::string& skey,
372  IOpaqueAddress* pAddress,
373  bool clearAddressFlag)
374 {
375  lock_t lock (m_mutex);
376  assert(0 != pAddress);
377  CLID dataID = pAddress->clID();
378 
379  if (dataID == 0)
380  {
381  warning() << "recordAddress: Invalid Class ID found in IOpaqueAddress @"
382  << pAddress << ". IOA will not be recorded"
383  << endmsg;
384  return StatusCode::FAILURE;
385  }
386 
387  //do not overwrite a persistent object
388  if (m_pPPS) {
389  DataProxy* dp = m_pStore->proxy (dataID, skey);
390  if (!dp) {
391  dp = m_pPPS->retrieveProxy(dataID, skey, *m_pStore);
392  }
393  if (dp && dp->provider()) {
394  std::string clidTypeName;
395  m_pCLIDSvc->getTypeNameOfID(dataID, clidTypeName).ignore();
396  warning() << "recordAddress: failed for key="<< skey << ", type "
397  << clidTypeName
398  << " (CLID " << dataID << ')'
399  << "\n there is already a persistent version of this object. Will not record a duplicate! "
400  << endmsg;
401  return StatusCode::FAILURE;
402  }
403  }
404 
405  // Check if a key already exists
406  DataProxy* dp = m_pStore->proxy_exact(dataID, skey);
407  if (0 == dp && 0 != m_pPPS) {
408  dp = m_pPPS->retrieveProxy(dataID, skey, *m_pStore);
409  }
410 
411  // Now treat the various cases:
412  if (0 == dp)
413  {
414  // create the proxy object and register it
415  dp = new DataProxy (TransientAddress (dataID, skey,
416  pAddress, clearAddressFlag),
417  m_pDataLoader.get(), true, true);
418  m_pStore->addToStore(dataID, dp).ignore();
419 
420  addAutoSymLinks (skey, dataID, dp, 0, false);
421  }
422  else if ((0 != dp) && (0 == dp->address()))
423  // Note: intentionally not checking dp->isValidAddress()
424  {
425  // Update proxy with IOpaqueAddress
426  dp->setAddress(pAddress);
427  }
428  else
429  {
430  string errType;
431  m_pCLIDSvc->getTypeNameOfID(dataID, errType).ignore();
432  warning() << "recordAddress: preexisting proxy @" << dp
433  << " with non-NULL IOA found for key "
434  << skey << " type " << errType << " (" << dataID << "). \n"
435  << "Cannot record IOpaqueAddress @" << pAddress
436  << endmsg;
437  return StatusCode::FAILURE;
438  }
439 
440  return StatusCode::SUCCESS;
441 
442 }
443 
446 // add proxy (with IOpaqueAddress that will later be retrieved from P)
448 StatusCode SGImplSvc::recordAddress(IOpaqueAddress* pAddress, bool clearAddressFlag)
449 {
450  lock_t lock (m_mutex);
451  assert(0 != pAddress);
452 
453  CLID dataID = pAddress->clID();
454 
455  string gK = (pAddress->par())[1]; // transient name by convention
456  if (gK.empty()) gK = (pAddress->par())[0]; // FIXME backward compatibility
457  if (gK.empty()) gK = createKey(dataID);
458 
459  return this->recordAddress(gK, pAddress, clearAddressFlag);
460 }
461 
463  const string& gK,
464  DataObject* pDObj,
465  bool allowMods,
466  bool resetOnly) {
467  // locate the proxy
468  DataProxy* dp = m_pStore->proxy_exact(dataID, gK);
469 
470  if (0 != dp) { //proxy found
471  if (0 != dp->object())
472  {
473  // Case 0: duplicated proxy
474  warning() << " setupProxy:: error setting up proxy for key "
475  << gK << " and clid " << dataID
476  << "\n Pre-existing valid DataProxy @"<< dp
477  << " found in Store for key " << dp->object()->name()
478  << " with clid " << dp->object()->clID()
479  << endmsg;
480  recycle(pDObj); // commit this object to trash
481  dp = 0;
482  } else {
483  // Case 1: Proxy found... if not valid, update it:
484  dp->setObject(pDObj);
485  if (!allowMods) dp->setConst();
486  }
487  } else {
488  // Case 2: No Proxy found:
489  dp = new DataProxy(pDObj,
490  TransientAddress(dataID, gK),
491  !allowMods, resetOnly);
492  if (!(m_pStore->addToStore(dataID, dp).isSuccess())) {
493  warning() << " setupProxy:: could not addToStore proxy @" << dp
494  << endmsg;
495  recycle(pDObj); // commit this object to trash
496  delete dp;
497  dp = 0;
498  }
499  }
500  return dp;
501 }
502 
505 {
506  lock_t lock (m_mutex);
507  store()->setStoreID(id);
508 }
511 {
512  lock_t lock (m_mutex);
513  return store()->storeID();
514 }
515 
516 
517 void
518 SGImplSvc::keys(const CLID& id, std::vector<std::string>& vkeys,
519  bool includeAlias, bool onlyValid)
520 
521 {
522  lock_t lock (m_mutex);
523  return store()->keys(id, vkeys, includeAlias, onlyValid);
524 }
525 
526 
527 bool SGImplSvc::isSymLinked(const CLID& linkID, DataProxy* dp)
528 {
529  return (0 != dp) ? dp->transientID(linkID) : false;
530 }
531 
532 
533 StatusCode
535  const CallBackID& c2,
536  const IOVSvcCallBackFcn& fcn,
537  bool trigger)
538 {
539  lock_t lock (m_mutex);
540  return ( m_pIOVSvc->regFcn(c1,c2,fcn,trigger) );
541 }
542 
543 
544 StatusCode
545 SGImplSvc::regFcn( const std::string& toolName,
546  const CallBackID& c2,
547  const IOVSvcCallBackFcn& fcn,
548  bool trigger)
549 {
550  lock_t lock (m_mutex);
551  return ( m_pIOVSvc->regFcn(toolName,c2,fcn,trigger) );
552 }
553 
554 
556 // Dump Contents in store:
557 string SGImplSvc::dump() const
558 {
559  lock_t lock (m_mutex);
560  auto out_buffer = std::string{};
561  auto out = std::back_inserter(out_buffer);
562  const std::string me = name();
563  std::format_to(out, "{}: <<<<<<<<<<<<<<<<< Data Store Dump >>>>>>>>>>>>>>> \n", me);
564  std::format_to(out, "{}: SGImplSvc()::dump() which is {} \n", me, m_storeLoaded ? "LOADED" : "NOT LOADED");
565 
566  DataStore::ConstStoreIterator s_iter, s_end;
567  store()->tRange(s_iter, s_end).ignore();
568 
569  for (; s_iter != s_end; ++s_iter)
570  {
571 
572  CLID id = s_iter->first;
573  int nProxy = store()->typeCount(id);
574  std::string tname;
575  m_pCLIDSvc->getTypeNameOfID(id, tname).ignore();
576  std::format_to(out, "{}: Found {} {} for ClassID {} ({}): \n", me, nProxy, ((nProxy == 1) ? "proxy" : "proxies"), id, tname);
577 
578  // loop over each type:
579  SG::ConstProxyIterator p_iter = (s_iter->second).begin();
580  SG::ConstProxyIterator p_end = (s_iter->second).end();
581 
582  while (p_iter != p_end) {
583  const DataProxy& dp(*p_iter->second);
584  std::format_to(out, "{}: flags: ({:7s}, {:8s}, {:6s}) --- data: {:10p} --- key: {}\n", me,
585  (dp.isValid() ? "valid" : "INVALID"),
586  (dp.isConst() ? "locked" : "UNLOCKED"),
587  (dp.isResetOnly() ? "reset" : "DELETE"),
588  dbg::ptr(dp.object()), p_iter->first);
589  ++p_iter;
590  }
591  }
592  std::format_to(out, "{}: <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>> \n", me);
593  return out_buffer;
594 }
595 
596 DataStore*
598 {
599  return m_pStore;
600 }
601 
602 const DataStore*
604 {
605  return m_pStore;
606 }
607 
608 
610 // Make a soft link to the object with key
612 StatusCode SGImplSvc::symLink(const void* pObject, CLID linkID)
613 {
614  lock_t lock (m_mutex);
615  SG::DataProxy* dp(proxy(pObject));
616 
617  // if symLink already exists, just return success
618  return isSymLinked(linkID,dp) ?
619  StatusCode::SUCCESS :
620  addSymLink(linkID,dp);
621 }
622 
623 StatusCode SGImplSvc::symLink(const CLID id, const std::string& key, const CLID linkID)
624 {
625  lock_t lock (m_mutex);
626  SG::DataProxy* dp(proxy(id, key, false));
627  // if symLink already exists, just return success
628  return isSymLinked(linkID,dp) ?
629  StatusCode::SUCCESS :
630  addSymLink(linkID,dp);
631 }
632 
633 
636 {
637  if (0 == dp) {
638  warning() << "addSymLink: no target DataProxy found. Sorry, can't link to a non-existing data object"
639  << endmsg;
640  return StatusCode::FAILURE;
641  }
642  StatusCode sc = m_pStore->addSymLink(linkid, dp);
643 
644  // If the symlink is a derived->base conversion, then we may have
645  // a different transient pointer for the symlink.
646  if (sc.isSuccess() && dp->object()) {
647  void* baseptr = SG::DataProxy_cast (dp, linkid);
648  if (baseptr)
649  this->t2pRegister (baseptr, dp).ignore();
650  }
651  return sc;
652 }
653 
654 
655 StatusCode SGImplSvc::setAlias(const void* pObject, const std::string& aliasKey)
656 {
657  lock_t lock (m_mutex);
658 
659  SG::DataProxy* dp(0);
660  dp = proxy(pObject);
661  if (0 == dp) {
662  error() << "setAlias: problem setting alias "
663  << aliasKey << '\n'
664  << "DataObject does not exist, record before setting alias."
665  << endmsg;
666  return StatusCode::FAILURE;
667  }
668 
669  StatusCode sc = addAlias(aliasKey, dp);
670  if (sc.isFailure()) {
671  error() << "setAlias: problem setting alias "
672  << aliasKey << '\n'
673  << "DataObject does not exist, record before setting alias."
674  << endmsg;
675  return StatusCode::FAILURE;
676  }
677 
678  return StatusCode::SUCCESS;
679 }
680 
681 
683  const std::string& key, const std::string& aKey)
684 {
685  lock_t lock (m_mutex);
686 
687  SG::DataProxy* dp(0);
688  dp = proxy(clid, key);
689  if (0 == dp) {
690  error() << "setAlias: problem setting alias "
691  << std::string(aKey) << '\n'
692  << "DataObject does not exist, record before setting alias."
693  << endmsg;
694  return StatusCode::FAILURE;
695  }
696 
697  StatusCode sc = addAlias(aKey, dp);
698  if (sc.isFailure()) {
699  error() << "setAlias: problem setting alias "
700  << (std::string)aKey << '\n'
701  << "DataObject does not exist, record before setting alias."
702  << endmsg;
703  return StatusCode::FAILURE;
704  }
705 
706  return StatusCode::SUCCESS;
707 }
708 
709 StatusCode SGImplSvc::setAlias(SG::DataProxy* proxy, const std::string& aliasKey)
710 {
711  return addAlias( aliasKey, proxy );
712 }
713 
715 SGImplSvc::addAlias(const std::string& aliasKey, DataProxy* proxy)
716 {
717  if (0 == proxy) {
718  warning() << "addAlias: no target DataProxy given, Cannot alias to a non-existing object"
719  << endmsg;
720  return StatusCode::FAILURE;
721  }
722 
723  // add key to proxy and to ProxyStore
724  return m_pStore->addAlias(aliasKey, proxy);
725 }
726 
727 int SGImplSvc::typeCount(const CLID& id) const
728 {
729  lock_t lock (m_mutex);
730  return m_pStore->typeCount(id);
731 }
732 
733 
734 bool
735 SGImplSvc::contains(const CLID id, const std::string& key) const
736 {
737  try {
738  return (0 != proxy(id, key, true));
739  } catch(...) { return false; }
740 }
741 
742 
743 bool
744 SGImplSvc::transientContains(const CLID id, const std::string& key) const
745 {
746  try {
747  return (0 != transientProxy(id, key));
748  } catch(...) { return false; }
749 }
750 
751 
752 DataProxy*
753 SGImplSvc::proxy(const void* const pTransient) const
754 {
755  // No lock needed here --- the T2pmap held by DataStore has its own locking
756  // (and we were seeing contention here).
757  //lock_t lock (m_mutex);
758  return m_pStore->locatePersistent(pTransient);
759 }
760 
761 DataProxy*
762 SGImplSvc::proxy(const CLID& id) const
763 {
764  return proxy(id, false);
765 }
766 
767 DataProxy*
768 SGImplSvc::proxy(const CLID& id, bool checkValid) const
769 {
770  DataProxy* dp = nullptr;
771  {
772  lock_t lock (m_mutex);
773  dp = m_pStore->proxy(id);
774  if (0 == dp && 0 != m_pPPS) {
776  dp = m_pPPS->retrieveProxy(id, string("DEFAULT"), *pStore);
777  }
778  }
780  // Be sure to release the lock before this.
781  // isValid() may call back to the store, so we could otherwise deadlock..
782  if (checkValid && 0 != dp) {
783  // FIXME: For keyless retrieve, this checks only the first instance
784  // of the CLID in store. If that happens to be invalid, but the second
785  // is valid - this does not work (when checkValid is requested).
786  return dp->isValid() ? dp : 0;
787  }
788  return dp;
789 }
790 
791 DataProxy*
792 SGImplSvc::proxy(const CLID& id, const string& key) const
793 {
794  return proxy(id, key, false);
795 }
796 
797 DataProxy*
798 SGImplSvc::proxy(const CLID& id, const string& key, bool checkValid) const
799 {
800  DataProxy* dp = nullptr;
801  {
802  lock_t lock (m_mutex);
803  dp = m_pStore->proxy(id, key);
804 #ifdef DEBUG_SGIMPL
805  if (!dp) dbg::print(stderr, "::SGImplSvc::proxy(name={}, key={}): data proxy is null, m_pPPS is {}\n", this->name(), key, m_pPPS == 0 ? "NULL" : "NOT NULL");
806 #endif
807  if (0 == dp && 0 != m_pPPS) {
809  dp = m_pPPS->retrieveProxy(id, key, *pStore);
810 #ifdef DEBUG_SGIMPL
811  if (!dp) dbg::print(stderr, "::SGImplSvc::proxy(name={}, key={}): data proxy is still null\n", this->name(), key);
812 #endif
813  }
814  }
815  // Be sure to release the lock before this.
816  // isValid() may call back to the store, so we could otherwise deadlock..
817  if (checkValid && 0 != dp && !(dp->isValid())) {
818  dp = 0;
819  }
820  return dp;
821 }
822 
823 
830 {
831  lock_t lock (m_mutex);
832  return m_pStore->addToStore (id, proxy);
833 }
834 
835 
857  const std::string& key,
858  bool allowMods,
859  bool returnExisting)
860 {
861  lock_t lock (m_mutex);
862  const void* raw_ptr = obj.get();
863  const std::type_info* tinfo = nullptr;
864 
865  if (DataBucketBase* bucket = dynamic_cast<DataBucketBase*> (obj.get())) {
866  raw_ptr = bucket->object();
867  tinfo = &bucket->tinfo();
868  }
869 
870  if (returnExisting) {
871  SG::DataProxy* proxy = this->proxy (obj->clID(), key);
872  if (proxy && proxy->isValid()) return proxy;
873 
874  // Look for the same object recorded under a different key/clid.
875  proxy = this->proxy (raw_ptr);
876  if (proxy && proxy->isValid()) {
877  if (proxy->transientID (obj->clID())) {
878  // CLID matches. Make an alias.
879  if (addAlias (key, proxy).isFailure()) {
880  CLID clid = proxy->clID();
881  std::string clidTypeName;
882  m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
883  warning() << "SGImplSvc::recordObject: addAlias fails for object "
884  << clid << "[" << clidTypeName << "] " << proxy->name()
885  << " and new key " << key
886  << endmsg;
887 
888  proxy = nullptr;
889  }
890  }
891 
892  else if (key == proxy->name() ||
893  proxy->alias().count (key) > 0)
894  {
895  // key matches. Make a symlink.
896  if (addSymLink (obj->clID(), proxy).isFailure()) {
897  CLID clid = proxy->clID();
898  std::string clidTypeName;
899  m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
900  CLID newclid = obj->clID();
901  std::string newclidTypeName;
902  m_pCLIDSvc->getTypeNameOfID(newclid, newclidTypeName).ignore();
903  error() << "SGImplSvc::recordObject: addSymLink fails for object "
904  << clid << "[" << clidTypeName << "] " << proxy->name()
905  << " and new clid " << newclid << "[" << newclidTypeName << "]"
906  << endmsg;
907  proxy = nullptr;
908  }
909  }
910 
911  else {
912  CLID clid = proxy->clID();
913  std::string clidTypeName;
914  m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
915  CLID newclid = obj->clID();
916  std::string newclidTypeName;
917  m_pCLIDSvc->getTypeNameOfID(newclid, newclidTypeName).ignore();
918  error() << "SGImplSvc::recordObject: existing object found with "
919  << clid << "[" << clidTypeName << "] " << proxy->name()
920  << " but neither clid " << newclid << "[" << newclidTypeName << "]"
921  << " nor key " << key << " match."
922  << endmsg;
923  proxy = nullptr;
924  }
925 
926  return proxy;
927  }
928  }
929 
930  const bool resetOnly = true;
931  const bool noHist = false;
932  SG::DataProxy* proxy = nullptr;
933  if (this->typeless_record (obj.get(), key, raw_ptr,
934  allowMods, resetOnly, noHist, tinfo,
935  &proxy, true).isFailure())
936  {
937  return nullptr;
938  }
939  return proxy;
940 }
941 
942 
947 {
949 }
950 
951 
958 void SGImplSvc::setSlotNumber (int slot, int numSlots)
959 {
960  m_slotNumber = slot;
961  m_numSlots = numSlots;
962 
964  header->setArenaForSlot (slot, &m_arena);
965 }
966 
967 
968 std::vector<const SG::DataProxy*>
970 {
971  lock_t lock (m_mutex);
972  const std::vector<SG::DataProxy*>& proxies = store()->proxies();
973  std::vector<const SG::DataProxy*> ret (proxies.begin(), proxies.end());
974  return ret;
975 }
976 
977 
978 std::vector<CLID>
980 {
981  lock_t lock (m_mutex);
982 
983  using std::distance;
984  DataStore::ConstStoreIterator s_iter, s_end;
985  store()->tRange(s_iter, s_end).ignore();
986 
987  std::vector<CLID> clids;
988  clids.reserve( distance( s_iter, s_end ) );
989 
990  for (; s_iter != s_end; ++s_iter ) {
991  const CLID id = s_iter->first;
992  clids.push_back (id);
993  }
994 
995  return clids;
996 }
997 
998 
999 DataProxy*
1000 SGImplSvc::transientProxy(const CLID& id, const string& key) const
1001 {
1002  lock_t lock (m_mutex);
1003  DataProxy* dp(m_pStore->proxy(id, key));
1004  return ( (0 != dp && dp->isValidObject()) ? dp : 0 );
1005 }
1006 
1007 DataObject*
1008 SGImplSvc::accessData(const CLID& id) const
1009 {
1010  lock_t lock (m_mutex);
1011  DataProxy* theProxy(proxy(id, true));
1012  return (0 == theProxy) ? 0 : theProxy->accessData();
1013 }
1014 
1015 DataObject*
1016 SGImplSvc::accessData(const CLID& id, const string& key) const
1017 {
1018  lock_t lock (m_mutex);
1019  DataProxy* theProxy(proxy(id, key, true));
1020  return (0 == theProxy) ? 0 : theProxy->accessData();
1021 }
1022 
1023 bool
1025  const std::string& keyA, const std::string& keyB )
1026 {
1027  lock_t lock (m_mutex);
1028  const bool checkValid = true;
1029  DataProxy* a = proxy( id, keyA, checkValid );
1030  DataProxy* b = proxy( id, keyB, checkValid );
1031  if ( 0 == a || 0 == b ) { return false; }
1032  DataObject* objA = a->accessData();
1033  DataObject* objB = b->accessData();
1034 
1035  if ( 0 == objA || 0 == objB ) { return false; }
1036  // prevent 'accidental' release of DataObjects...
1037  const unsigned int refCntA = objA->addRef();
1038  const unsigned int refCntB = objB->addRef();
1039  // in case swap is being specialized for DataObjects
1040  using std::swap;
1041  swap( objA, objB );
1042  a->setObject( objA );
1043  b->setObject( objB );
1044  // and then restore old ref-count;
1045  return ( (refCntA-1) == objA->release() &&
1046  (refCntB-1) == objB->release() );
1047 }
1048 
1049 StatusCode
1050 SGImplSvc::typeless_record( DataObject* obj, const std::string& key,
1051  const void* const raw_ptr,
1052  bool allowMods, bool resetOnly, bool noHist)
1053 {
1054  return typeless_record (obj, key, raw_ptr, allowMods, resetOnly, noHist, 0,
1055  nullptr, true);
1056 }
1057 
1058 
1059 StatusCode
1060 SGImplSvc::typeless_record( DataObject* obj, const std::string& key,
1061  const void* const raw_ptr,
1062  bool allowMods, bool resetOnly, bool noHist,
1063  const std::type_info* tinfo)
1064 {
1065  return typeless_record (obj, key, raw_ptr, allowMods, resetOnly, noHist,tinfo,
1066  nullptr, true);
1067 }
1068 
1069 
1070 StatusCode
1071 SGImplSvc::typeless_record( DataObject* obj, const std::string& key,
1072  const void* const raw_ptr,
1073  bool allowMods, bool resetOnly, bool noHist,
1074  const std::type_info* tinfo,
1075  SG::DataProxy** proxy_ret,
1076  bool noOverwrite)
1077 {
1078  lock_t lock (m_mutex);
1079  SG::DataProxy* proxy =
1080  record_impl( obj, key, raw_ptr, allowMods, resetOnly, !noOverwrite, tinfo);
1081  if ( proxy == nullptr )
1082  return StatusCode::FAILURE;
1083  if (proxy_ret)
1084  *proxy_ret = proxy;
1085 
1086  if ( !m_ActivateHistory || noHist ) {
1087  return StatusCode::SUCCESS;
1088  }
1089 
1090  if ( store()->storeID() != StoreID::EVENT_STORE ) {
1091  return StatusCode::SUCCESS;
1092  } else {
1093  return record_HistObj( obj->clID(), key, name(), allowMods, resetOnly );
1094  }
1095 }
1096 
1097 StatusCode
1099  DataObject* obj,
1100  const std::string& key,
1101  const void* const raw_ptr,
1102  bool allowMods,
1103  bool noHist,
1104  const std::type_info* tinfo)
1105 {
1106  lock_t lock (m_mutex);
1107  StatusCode sc(StatusCode::SUCCESS);
1108  SG::DataProxy* toRemove(proxy(clid, key, false));
1109  if (0 != toRemove) {
1110  toRemove->addRef();
1111  const bool FORCEREMOVE(true);
1112  sc =removeProxy(toRemove, (void*)0, FORCEREMOVE);
1113  }
1114  if (sc.isSuccess()) {
1115  const bool ALLOWOVERWRITE(true);
1116  const bool NORESET(false);
1117  if (record_impl( obj, key, raw_ptr, allowMods, NORESET, ALLOWOVERWRITE, tinfo) == nullptr)
1118  sc = StatusCode::FAILURE;
1119  else if ( m_ActivateHistory && noHist && store()->storeID() == StoreID::EVENT_STORE ) {
1120  sc = record_HistObj( obj->clID(), key, name(), allowMods, NORESET );
1121  }
1122  }
1123  //for detector store objects managed by IIOVSvc, replace the old proxy with the new one (#104311)
1124  if (toRemove && sc.isSuccess() && store()->storeID() == StoreID::DETECTOR_STORE) {
1125  sc = m_pIOVSvc->replaceProxy(toRemove, proxy(clid, key));
1126  }
1127  if (toRemove)
1128  toRemove->release();
1129  return sc;
1130 }
1131 
1133 SGImplSvc::record_impl( DataObject* pDObj, const std::string& key,
1134  const void* const raw_ptr,
1135  bool allowMods, bool resetOnly, bool allowOverwrite,
1136  const std::type_info* tinfo)
1137 {
1138  CLID clid = pDObj->clID();
1139  std::string rawKey(key);
1140  bool isVKey(SG::VersionedKey::isVersionedKey(key));
1141  if (isVKey) {
1142  //FIXME VersionedKeys will need to be handled more efficiently
1143  SG::VersionedKey vk(rawKey);
1144  DataProxy *dp(proxy(clid, vk.key()));
1145  if (dp) {
1146  //proxies primary key
1147  const std::string& pTAName(dp->name());
1148  //original key as versioned
1149  SG::VersionedKey primaryVK(pTAName);
1150 
1151  //if the existing matching object has no version
1152  //create a versioned alias for the original unversioned key
1153  //so it will remain accessible
1154  if (!SG::VersionedKey::isVersionedKey(pTAName)) {
1155  if (!(this->addAlias(primaryVK.rawVersionKey(), dp)).isSuccess()) {
1156  warning() << "record_impl: Could not setup alias key "
1157  << primaryVK.rawVersionKey()
1158  << " for unversioned object " << pTAName
1159  << endmsg;
1160  return nullptr;
1161  }
1162  }
1163  if (vk.isAuto()) {
1164  //make a new versioned key incrementing the existing version
1165  SG::VersionedKey newVK(primaryVK.key(), primaryVK.version()+1);
1166  //FIXME this will fail in a confusing way if version+1 is in use
1167  //FIXME need a better error message below, probably looking at all
1168  //FIXME aliases
1169  rawKey = newVK.rawVersionKey();
1170  }
1171  }
1172  }
1173  if (!allowOverwrite && m_pPPS) {
1174  //do not overwrite a persistent object
1175  DataProxy* dp = m_pStore->proxy (clid, rawKey);
1176  if (!dp) {
1177  dp = m_pPPS->retrieveProxy(clid, rawKey, *m_pStore);
1178  }
1179  if (dp && dp->provider()) {
1180  std::string clidTypeName;
1181  m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
1182  warning() << "record_impl: you are recording an object with key "
1183  << rawKey << ", type " << clidTypeName
1184  << " (CLID " << clid << ')'
1185  << "\n There is already a persistent version of this object. Recording a duplicate may lead to unreproducible results and it is deprecated."
1186  << endmsg;
1187  }
1188  }
1189  //now check whether raw_ptr has already been recorded
1190  //We need to do this before we create the bucket, the proxy etc
1191  SG::DataProxy* dp(proxy(raw_ptr));
1192  if (0 != dp) {
1193  std::string clidTypeName;
1194  m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
1195  warning() << "record_impl: failed for key="<< rawKey << ", type "
1196  << clidTypeName
1197  << " (CLID " << clid << ')'
1198  << "\n object @" << raw_ptr
1199  << " already in store with key="<< dp->name()
1200  << ". Will not record a duplicate! "
1201  << endmsg;
1202  if (pDObj != dp->object()) {
1203  DataBucketBase* pDBB(dynamic_cast<DataBucketBase*>(pDObj));
1204  if (!pDBB) std::abort();
1205  pDBB->relinquish(); //don't own the data obj already recorded!
1206  }
1207  this->recycle(pDObj);
1208  return nullptr;
1209  }
1210 
1211 
1212  // setup the proxy
1213  dp = setupProxy( clid, rawKey, pDObj, allowMods, resetOnly );
1214  if ( 0 == dp ) {
1215  std::string clidTypeName;
1216  m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
1217  warning() << "record_impl: Problem setting up the proxy for object @"
1218  << raw_ptr
1219  << "\n recorded with key " << rawKey
1220  << " of type " << clidTypeName
1221  << " (CLID " << clid << ") in DataObject @" << pDObj
1222  << endmsg;
1223 
1224  return nullptr;
1225  }
1226 
1227  // record in t2p:
1228  if ( !(this->t2pRegister( raw_ptr, dp )).isSuccess() ) {
1229  std::string clidTypeName;
1230  m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
1231  warning() << "record_impl: can not add to t2p map object @" <<raw_ptr
1232  << "\n with key " << rawKey
1233  << " of type " << clidTypeName
1234  << " (CLID " << clid << ')'
1235  << endmsg;
1236  return nullptr;
1237  }
1238 
1239  addAutoSymLinks (rawKey, clid, dp, tinfo);
1240 
1241  //handle versionedKeys: we register an alias with the "true" key
1242  //unless an object as already been recorded with that key.
1243  //Notice that addAlias overwrites any existing alias, so a generic
1244  //retrieve will always return the last version added
1245  //FIXME not the one with the highest version
1246  if (isVKey) {
1247  SG::VersionedKey vk(rawKey);
1248  if (!(this->addAlias(vk.key(), dp)).isSuccess()) {
1249  warning() << "record_impl: Could not setup alias key " << vk.key()
1250  << " for VersionedKey " << rawKey
1251  << ". Generic access to this object with clid" << clid
1252  << " will not work"
1253  << endmsg;
1254  }
1255  }
1256 
1257  return dp;
1258 }
1259 
1260 DataProxy*
1262  bool checkValid) const
1263 {
1264  DataProxy* dp = m_pStore->proxy(tAddr);
1265 
1266  if (checkValid && 0 != dp) {
1267  return dp->isValid() ? dp : 0;
1268  } else {
1269  return dp;
1270  }
1271 }
1272 
1273 StatusCode
1275  bool forceRemove)
1276 {
1277  lock_t lock (m_mutex);
1278  // check if valid proxy
1279  if (0 == proxy) return StatusCode::FAILURE;
1280 
1281  if (0 == pTrans) {
1282  DataBucketBase* bucket = dynamic_cast<DataBucketBase*>(proxy->object());
1283  if (bucket) pTrans = bucket->object();
1284  }
1285 
1286  // remove all entries from t2p map
1287  // --- only if the proxy actually has an object!
1288  // otherwise, we can trigger I/O.
1289  // besides being useless here, we can get deadlocks if we
1290  // call into the I/O code while holding the SG lock.
1291  if (proxy->isValidObject()) {
1292  this->t2pRemove(pTrans);
1294  for (SG::DataProxy::CLIDCont_t::const_iterator i = clids.begin();
1295  i != clids.end();
1296  ++i)
1297  {
1298  void* ptr = SG::DataProxy_cast (proxy, *i);
1299  this->t2pRemove(ptr);
1300  }
1301  }
1302 
1303  // remove from store
1304  return m_pStore->removeProxy(proxy, forceRemove, true);
1305 }
1306 
1307 StatusCode
1308 SGImplSvc::t2pRegister(const void* const pTrans, DataProxy* const pPers)
1309 {
1310  return m_pStore->t2pRegister(pTrans, pPers);
1311 }
1312 
1313 
1314 void
1315 SGImplSvc::t2pRemove(const void* const pTrans)
1316 {
1317  m_pStore->t2pRemove(pTrans);
1318 }
1319 
1320 void
1321 SGImplSvc::msg_update_handler(Gaudi::Details::PropertyBase& /*outputLevel*/)
1322 {
1323  setUpMessaging();
1324  updateMsgStreamOutputLevel( outputLevel() );
1325  msgSvc()->setOutputLevel(name(), outputLevel());
1326 }
1327 
1328 StatusCode
1331  SG::ConstProxyIterator& end) const {
1332  lock_t lock (m_mutex);
1333  return m_pStore->pRange(id,begin,end);
1334 }
1335 
1336 StatusCode SGImplSvc::setConst(const void* pObject)
1337 {
1338  lock_t lock (m_mutex);
1339  // Check if DataProxy does not exist
1340  DataProxy * dp = proxy(pObject);
1341 
1342  if (0 == dp)
1343  {
1344  warning() << "setConst: NO Proxy for the dobj you want to set const"
1345  << endmsg;
1346  return StatusCode::FAILURE;
1347  }
1348 
1349  dp->setConst();
1350  return StatusCode::SUCCESS;
1351 }
1352 
1353 
1354 // remove an object from Store, will remove its proxy if not reset only
1355 StatusCode
1356 SGImplSvc::remove(const void* pObject)
1357 {
1358  lock_t lock (m_mutex);
1359  return removeProxy(proxy(pObject), pObject);
1360 }
1361 
1362 
1363 // remove an object and its proxy from Store
1364 StatusCode
1365 SGImplSvc::removeDataAndProxy(const void* pObject)
1366 {
1367  lock_t lock (m_mutex);
1368  const bool FORCEREMOVE(true);
1369  return removeProxy(proxy(pObject), pObject, FORCEREMOVE);
1370 }
1371 
1372 //put a bad (unrecordable) dobj away
1373 void SGImplSvc::recycle(DataObject* pBadDObj) {
1374  assert(pBadDObj);
1375  pBadDObj->addRef();
1376  m_trash.push_back(pBadDObj);
1377 }
1378 
1379 //throw away bad objects
1381  lock_t lock (m_mutex);
1382  while (!m_trash.empty()) {
1383  m_trash.front()->release(); //delete the bad data object
1384  m_trash.pop_front(); //remove pointer from list
1385  }
1386 }
1387 
1388 
1389 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1390 
1391 bool SGImplSvc::bindHandleToProxy(const CLID& id, const string& key,
1392  IResetable* ir, DataProxy *&dp)
1393 {
1394  lock_t lock (m_mutex);
1395 
1396  dp = m_pStore->proxy (id, key);
1397  if (dp == nullptr && m_pPPS != nullptr) {
1398  dp = m_pPPS->retrieveProxy(id, key, *m_pStore);
1399  }
1400 
1401  if (0 == dp) return false;
1402 
1403  if (! dp->bindHandle(ir) ) {
1404  fatal() << "DataHandle at " << hex << ir << dec
1405  << " already bound to DataProxy with key " << ir->key()
1406  << ". Cannot bind to proxy " << dp->name() << " as well\n"
1407  << " You have probably registered multiple callbacks via regFcn with the same DataHandle using different keys (DataProxies)\n"
1408  << endmsg;
1409  return false;
1410  }
1411 
1412  //already done in DataHandleBase::setState dp->addRef();
1413 
1414 #ifndef NDEBUG
1415  SG_MSG_DEBUG(" Bound handle " << MSG::hex << ir << " to proxy "
1416  << dp << MSG::dec);
1417 #endif
1418  return true;
1419 }
1420 
1421 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1422 
1423 bool SGImplSvc::bindHandleToProxyAndRegister (const CLID& id, const std::string& key,
1425 {
1426  lock_t lock (m_mutex);
1427  bool ret = bindHandleToProxy (id, key, ir, dp);
1428  if (ret) {
1429  StatusCode sc = m_pIOVSvc->regProxy(dp,key);
1430  if (sc.isFailure()) return false;
1431  }
1432  return true;
1433 }
1434 
1435 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1436 
1437 bool SGImplSvc::bindHandleToProxyAndRegister (const CLID& id, const std::string& key,
1439  const CallBackID& c,
1440  const IOVSvcCallBackFcn& fcn,
1441  bool trigger)
1442 {
1443  lock_t lock (m_mutex);
1444  bool ret = bindHandleToProxy (id, key, ir, dp);
1445  if (ret) {
1446  StatusCode sc = m_pIOVSvc->regProxy(dp,key);
1447  if (sc.isFailure()) return false;
1448  sc = m_pIOVSvc->regFcn(dp,c,fcn,trigger);
1449  if (sc.isFailure()) return false;
1450  }
1451  return true;
1452 }
1453 
1454 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1455 
1456 StatusCode
1457 SGImplSvc::record_HistObj(const CLID& id, const std::string& key,
1458  const std::string& store,
1459  bool allowMods, bool resetOnly) {
1460 
1461  DataHistory *dho;
1462  dho = m_pHistorySvc->createDataHistoryObj( id, key, store );
1463 
1464  std::string idname;
1465  StatusCode sc = m_pCLIDSvc->getTypeNameOfID(id, idname);
1466  if (sc.isFailure() || idname.empty() ) {
1467  idname = std::to_string(id);
1468  }
1469  idname += '/';
1470  idname += key;
1471 
1472  DataObject* obj = SG::asStorable(dho);
1473 
1474  const bool ALLOWOVERWRITE(false);
1475  if (record_impl(obj, idname, dho, allowMods, resetOnly, ALLOWOVERWRITE,
1476  &typeid(DataHistory)) == nullptr)
1477  return StatusCode::FAILURE;
1478  return StatusCode::SUCCESS;
1479 }
1480 
1481 
1491 SGImplSvc::stringToKey (const std::string& str, CLID clid)
1492 {
1493  lock_t lock (m_stringPoolMutex);
1494  return m_stringpool.stringToKey (str, clid);
1495 }
1496 
1497 
1505 const std::string* SGImplSvc::keyToString (sgkey_t key) const
1506 {
1507  lock_t lock (m_stringPoolMutex);
1508  return m_stringpool.keyToString (key);
1509 }
1510 
1511 
1520 const std::string*
1522 {
1523  lock_t lock (m_stringPoolMutex);
1524  return m_stringpool.keyToString (key, clid);
1525 }
1526 
1527 
1541  const std::string& str,
1542  CLID clid)
1543 {
1544  lock_t lock (m_stringPoolMutex);
1545  if (!m_stringpool.registerKey (key, str, clid)) {
1546  CLID clid2;
1547  const std::string* str2 = m_stringpool.keyToString (key, clid2);
1548  REPORT_MESSAGE (MSG::WARNING) << "The numeric key " << key
1549  << " maps to multiple string key/CLID pairs: "
1550  << *str2 << "/" << clid2 << " and "
1551  << str << "/" << clid;
1552  }
1553 }
1554 
1555 
1564 {
1565  // We should hold m_stringPoolMutex before touching the pool.
1566  // But if we acquire the locks for both this and the other store,
1567  // we risk a deadlock. So first copy the other pool, so that we
1568  // don't need to hold both locks at the same time.
1570  {
1571  lock_t lock (other.m_stringPoolMutex);
1572  tmp = other.m_stringpool;
1573  }
1574  lock_t lock (m_stringPoolMutex);
1575  return m_stringpool.merge (tmp);
1576 }
1577 
1578 
1579 void
1580 SGImplSvc::releaseObject(const CLID& id, const std::string& key) {
1581  lock_t lock (m_mutex);
1582  DataProxy *pP(0);
1583  if (0 != (pP = proxy(id, key))) {
1584  // remove all entries from t2p map
1586  SG::DataProxy::CLIDCont_t::const_iterator i(clids.begin()), e(clids.end());
1587  while (i != e) t2pRemove(SG::DataProxy_cast (pP, *i++));
1588  DataBucketBase *pDBB(dynamic_cast<DataBucketBase*>(pP->object()));
1589  //tell the bucket to let go of the data object
1590  if (0 != pDBB) pDBB->relinquish(); //somebody else better took ownership
1591  bool hard_reset = (m_numSlots > 1);
1592  pP->reset (hard_reset);
1593  }
1594 }
1595 
1596 void
1598  lock_t lock (m_mutex);
1599 
1600  // Remove transient pointer entries for this proxy.
1601  // But do that only if the proxy has a valid object.
1602  // Otherwise, we could trigger I/O --- which we don't want since it's useless
1603  // (we'd just destroy the object immediately). In some cases it can also
1604  // lead to a deadlock (see ATR-24482).
1605  if (dp->isValidObject()) {
1606  SG::DataProxy::CLIDCont_t clids = dp->transientID();
1607  SG::DataProxy::CLIDCont_t::const_iterator i(clids.begin()), e(clids.end());
1608  while (i != e) {
1610  }
1611  }
1612 
1613  bool hard_reset = (m_numSlots > 1);
1614  dp->reset (hard_reset);
1615 }
1616 
1617 
1626  sgkey_t target,
1627  off_t index_offset)
1628 {
1629  lock_t lock (m_remapMutex);
1631  payload.target = target;
1632  payload.index_offset = index_offset;
1634 }
1635 
1636 
1645 bool SGImplSvc::tryELRemap (sgkey_t sgkey_in, size_t index_in,
1646  sgkey_t& sgkey_out, size_t& index_out)
1647 {
1648  lock_t lock (m_remapMutex);
1650  m_remap_impl->m_remaps.find (sgkey_in);
1651  if (i == m_remap_impl->m_remaps.end())
1652  return false;
1653  const SG::RemapImpl::remap_t& payload = i->second;
1654  sgkey_out = payload.target;
1655  index_out = index_in + payload.index_offset;
1656  return true;
1657 }
1658 
1659 
1661  const std::string& key)
1662 {
1663  lock_t lock (m_mutex);
1664  DataObject* obj = nullptr;
1665  SG::DataProxy* dp = proxy (clid, key);
1666  //we do not want anyone to mess up with our copy hence we release it immediately.
1667  if (dp && dp->isValid()) {
1668  obj = dp->object();
1669  obj->addRef();
1671  }
1672  return obj;
1673 }
1674 
1675 
1676 CLID SGImplSvc::clid( const std::string& key ) const
1677 {
1678  lock_t lock (m_mutex);
1679  SG::DataStore::ConstStoreIterator s_iter, s_end;
1680  store()->tRange(s_iter, s_end).ignore();
1681 
1682  for ( ; s_iter != s_end; ++s_iter ) {
1683  if ( s_iter->second.find( key ) != s_iter->second.end() ) {
1684  return s_iter->first;
1685  }
1686  }
1687 
1688  return CLID_NULL;
1689 }
1690 
1691 
1692 std::vector<CLID> SGImplSvc::clids( const std::string& key ) const
1693 {
1694  lock_t lock (m_mutex);
1695  std::vector<CLID> clids;
1696  SG::DataStore::ConstStoreIterator s_iter, s_end;
1697  store()->tRange(s_iter, s_end).ignore();
1698 
1699  for ( ; s_iter != s_end; ++s_iter ) {
1700  if ( s_iter->second.find( key ) != s_iter->second.end() ) {
1701  clids.push_back(s_iter->first);
1702  }
1703  }
1704 
1705  return clids;
1706 }
1707 
1708 
1710 void SGImplSvc::addAutoSymLinks (const std::string& key,
1711  CLID clid,
1712  DataProxy* dp,
1713  const std::type_info* tinfo,
1714  bool warn_nobib /*= true*/)
1715 {
1716  // Automatically make all legal base class symlinks
1717  if (!tinfo) {
1719  }
1720  const SG::BaseInfoBase* bib = nullptr;
1721  if (tinfo) {
1722  bib = SG::BaseInfoBase::find (*tinfo);
1723  }
1724  if (!bib) {
1725  // Could succeed where the previous fails if clid for DataVector<T>
1726  // but tinfo is for ConstDataVector<DataVector<T> >.
1727  bib = SG::BaseInfoBase::find (clid);
1728  }
1729  if ( bib ) {
1730  const std::vector<CLID>& bases = bib->get_bases();
1731  for ( std::size_t i = 0, iMax = bases.size(); i < iMax; ++i ) {
1732  if ( bases[i] != clid ) {
1733  if ( addSymLink( bases[i], dp ).isSuccess() ) {
1734  // register with t2p
1735  if (dp->object())
1736  this->t2pRegister( SG::DataProxy_cast( dp, bases[i] ), dp ).ignore();
1737  }
1738  else {
1739  warning() << "record_impl: Doing auto-symlinks for object with CLID "
1740  << clid
1741  << " and SG key " << key
1742  << ": Proxy already set for base CLID " << bases[i]
1743  << "; not making auto-symlink." << endmsg;
1744  }
1745  }
1746  }
1747 
1748  // Handle copy conversions.
1749  {
1750  for (CLID copy_clid : bib->get_copy_conversions()) {
1751  if (m_pStore->addSymLink (copy_clid, dp).isFailure()) {
1752  warning() << "record_impl: Doing auto-symlinks for object with CLID "
1753  << clid
1754  << " and SG key " << key
1755  << ": Proxy already set for copy-conversion CLID "
1756  << copy_clid
1757  << "; not making auto-symlink." << endmsg;
1758  }
1759  }
1760  }
1761  }
1762  else {
1763  if (warn_nobib) {
1764  warning() << "record_impl: Could not find suitable SG::BaseInfoBase for CLID ["
1765  << clid << "] (" << key << ") !\t"
1766  << "No auto-symlink established !"
1767  << endmsg;
1768  }
1769  }
1770 }
1771 
1772 void
1774  lock_t lock (m_mutex);
1775 
1776  // Reset handles added since the last call to commit.
1777  bool hard_reset = (m_numSlots > 1);
1778  std::vector<IResetable*> handles;
1779  m_newBoundHandles[std::this_thread::get_id()].swap (handles);
1780  for (IResetable* h : handles)
1781  h->reset (hard_reset);
1782 }
1783 
1784 
1790 void
1792 {
1793  m_newBoundHandles[std::this_thread::get_id()].push_back (handle);
1794 }
1795 
1796 
1802 void
1804 {
1805  std::vector<IResetable*>& v = m_newBoundHandles[std::this_thread::get_id()];
1807  std::find (v.begin(), v.end(), handle);
1808  if (it != v.end())
1809  v.erase (it);
1810 }
1811 
1812 
1816 {
1817  lock_t lock (m_mutex);
1818  m_arena.makeCurrent();
1820 }
1821 
1822 
1833 StatusCode
1834 SGImplSvc::createObj (IConverter* cvt,
1835  IOpaqueAddress* addr,
1836  DataObject*& refpObject)
1837 {
1838  // This lock was here originally, but is probably not really needed ---
1839  // both DataProxy and the I/O components have their own locks.
1840  // Further, this was observed to cause deadlocks for the detector store,
1841  // and would in general be expected to be a contention issue.
1842  //lock_t lock (m_mutex);
1843  return cvt->createObj (addr, refpObject);
1844 }
1845 
1846 
1847 // This is intended to be called from the debugger.
1848 void SG_dump (SGImplSvc* sg)
1849 {
1850  std::cout << sg->dump() << "\n";
1851 }
1852 void SG_dump (SGImplSvc* sg, const char* fname)
1853 {
1854  std::ofstream f (fname);
1855  f << sg->dump() << "\n";
1856  f.close();
1857 }
1858 
1859 
1866 SG::SourceID SGImplSvc::sourceID (const std::string& key /*= "EventSelector"*/) const
1867 {
1868  lock_t lock (m_mutex);
1870  if (dp) {
1871  const DataHeader* dh = SG::DataProxy_cast<DataHeader> (dp);
1872  if (dh) {
1873  return dh->begin()->getToken()->dbID().toString();
1874  }
1875  }
1876  return "";
1877 }
1878 
1879 
1881 // Retrieve a list of collections from Transient Store with no Key.
1882 // const version
1885  SG::detail::IteratorBase& cibegin,
1886  SG::detail::IteratorBase& ciend) const
1887 {
1888  lock_t lock (m_mutex);
1891 
1892  if (!(proxyRange(clid,first,end)).isSuccess()) {
1893  std::string typnam;
1894  m_pCLIDSvc->getTypeNameOfID(clid, typnam).ignore();
1895  SG_MSG_DEBUG("retrieve(range): no object found "
1896  << " of type " << typnam
1897  << "(CLID " << clid << ')');
1898  }
1899 
1900  (ciend.setState(end, end, true)).ignore();
1901 
1902  if (!(cibegin.setState(first, end, true)).isSuccess()) {
1903  std::string typnam;
1904  m_pCLIDSvc->getTypeNameOfID(clid, typnam).ignore();
1905  SG_MSG_DEBUG("retrieve(range): Can't initialize iterator for object range "
1906  << " of type " << typnam
1907  << "(CLID " << clid << ')');
1908  return StatusCode::FAILURE;
1909  }
1910 
1911  return StatusCode::SUCCESS;
1912 }
1913 
1914 
1916  const std::string& key,
1917  CLID auxclid) const
1918 {
1919  // If we already have the aux store (as should usually be the case), return
1920  // without taking out the SG lock. Otherwise, we can deadlock
1921  // if another thread is also trying to dereference a link to the aux store.
1922  // (Should _not_ be holding the SG lock when dereferencing the link!)
1923  if (ptr->hasStore()) return true;
1924 
1925  lock_t lock (m_mutex);
1926  SG_MSG_VERBOSE("called associateAux_impl for key " + key);
1927  // no Aux store set yet
1928  if (!ptr->hasStore()) {
1929  SG::DataProxy* dp = proxy (auxclid, key + "Aux.", true);
1930  if (dp) {
1931  if (!dp->isConst()) {
1932  SG::IAuxStore* pAux = SG::DataProxy_cast<SG::IAuxStore> (dp);
1933  if (pAux) {
1934  ptr->setStore (pAux);
1935  return true;
1936  }
1937  }
1938 
1939  const SG::IConstAuxStore* pAux = SG::DataProxy_cast<SG::IConstAuxStore> (dp);
1940  if (pAux) {
1941  ptr->setStore (pAux);
1942  return true;
1943  }
1944  }
1945  }
1946  return false;
1947 }
1948 
1949 
1951  const std::string& key,
1952  CLID auxclid) const
1953 {
1954  lock_t lock (m_mutex);
1955  SG_MSG_VERBOSE("called associateAux_impl for key " + key);
1956  // no Aux store set yet
1957  if (!ptr->hasStore()) {
1958  SG::DataProxy* dp = proxy (auxclid, key + "Aux.", true);
1959  if (dp) {
1960  if (!dp->isConst()) {
1961  SG::IAuxStore* pAux = SG::DataProxy_cast<SG::IAuxStore> (dp);
1962  if (pAux) {
1963  ptr->setStore (pAux);
1964  return true;
1965  }
1966  }
1967 
1968  const SG::IConstAuxStore* pAux = SG::DataProxy_cast<SG::IConstAuxStore> (dp);
1969  if (pAux) {
1970  ptr->setStore (pAux);
1971  return true;
1972  }
1973  }
1974  }
1975  return false;
1976 }
grepfile.info
info
Definition: grepfile.py:38
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
SGImplSvc::mergeStringPool
bool mergeStringPool(const SGImplSvc &other)
Merge the string pool from another store into this one.
Definition: SGImplSvc.cxx:1563
SG::VersionedKey::isVersionedKey
static bool isVersionedKey(const char *)
quickly determine whether a string has the right format to be a VK
Definition: SGVersionedKey.cxx:18
SGImplSvc::associateAux_impl
bool associateAux_impl(SG::AuxVectorBase *ptr, const std::string &key, CLID auxclid) const
Definition: SGImplSvc.cxx:1915
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
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
store
StoreGateSvc * store
Definition: fbtTestBasics.cxx:71
common.sgkey
def sgkey(tool)
Definition: common.py:1028
CurrentEventStore.h
Hold a pointer to the current event store.
CallBackID
Definition: CallBackID.h:24
SGImplSvc::setAlias
StatusCode setAlias(CLID clid, const std::string &key, const std::string &aliasKey)
make an alias to a DataObject (provide data type and old key)
Definition: SGImplSvc.cxx:682
TileDCSDataPlotter.dp
dp
Definition: TileDCSDataPlotter.py:840
SGImplSvc::contains
bool contains(const CLID id, const std::string &key) const
Look up a keyed object in TDS by CLID.
Definition: SGImplSvc.cxx:735
SGImplSvc::createObj
virtual StatusCode createObj(IConverter *cvt, IOpaqueAddress *addr, DataObject *&refpObject) override
Call converter to create an object, with locking.
Definition: SGImplSvc.cxx:1834
SGImplSvc::addSymLink
StatusCode addSymLink(const CLID &linkid, SG::DataProxy *dp)
Definition: SGImplSvc.cxx:635
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:50
SGImplSvc::setConst
StatusCode setConst(const void *pointer)
prevent downstream clients from modifying the pointed-at dobj
Definition: SGImplSvc.cxx:1336
SGImplSvc::SGImplSvc
SGImplSvc(const SGImplSvc &)=delete
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
SG::DataStore::t2pRegister
StatusCode t2pRegister(const void *const pTrans, DataProxy *const pPers)
methods to query the T2PMap:
Definition: Control/SGTools/src/DataStore.cxx:613
SGImplSvc::locatePersistent
SG::DataProxy * locatePersistent(const SG::TransientAddress *tAddr, bool checkValid=false) const
Definition: SGImplSvc.cxx:1261
header
Definition: hcg.cxx:526
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
SG::RemapImpl::remap_t::target
sgkey_t target
Definition: SGImplSvc.cxx:89
SGImplSvc::clearStore
virtual StatusCode clearStore(bool forceRemove=false) override final
clear DataStore contents: called by the event loop mgrs
Definition: SGImplSvc.cxx:268
SG
Forward declaration.
Definition: CaloCellPacker_400_500.h:32
SGImplSvc::commitNewDataObjects
virtual void commitNewDataObjects() override final
Reset handles added since the last call to commit.
Definition: SGImplSvc.cxx:1773
vtune_athena.format
format
Definition: vtune_athena.py:14
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
DataBucketBase
A non-templated base class for DataBucket, allows to access the transient object address as a void*.
Definition: DataBucketBase.h:24
SGImplSvc::recordObject
virtual SG::DataProxy * recordObject(SG::DataObjectSharedPtr< DataObject > obj, const std::string &key, bool allowMods, bool returnExisting) override final
Record an object in the store.
Definition: SGImplSvc.cxx:856
SG::StringPool
Definition: StringPool.h:35
IProxyProviderSvc::loadProxies
virtual StatusCode loadProxies(IProxyRegistry &dataStore)=0
add new proxies to store every Event:
DataBucketBase.h
SG::VersionedKey::version
unsigned char version() const
Definition: SGVersionedKey.cxx:67
SG::AuxElement
Base class for elements of a container that can have aux data.
Definition: AuxElement.h:483
DataBucketBase::object
virtual void * object()=0
initialize
void initialize()
Definition: run_EoverP.cxx:894
SG_dump
void SG_dump(SGImplSvc *sg)
These are intended to be easy to call from the debugger.
Definition: SGImplSvc.cxx:1848
DataStore.h
SGImplSvc::boundHandle
virtual void boundHandle(IResetable *handle) override final
Tell the store that a proxy has been bound to a handle.
Definition: SGImplSvc.cxx:1791
extractSporadic.c1
c1
Definition: extractSporadic.py:134
CSV_InDetExporter.new
new
Definition: CSV_InDetExporter.py:145
SGVersionedKey.h
SGImplSvc::removeProxy
StatusCode removeProxy(SG::DataProxy *proxy, const void *pTrans, bool forceRemove=false)
remove proxy from store, unless it is reset only.
Definition: SGImplSvc.cxx:1274
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
SG::RemapImpl::sgkey_t
IStringPool::sgkey_t sgkey_t
Definition: SGImplSvc.cxx:86
skel.it
it
Definition: skel.GENtoEVGEN.py:396
SGImplSvc::stringToKey
virtual sgkey_t stringToKey(const std::string &str, CLID clid) override final
Find the key for a string/CLID pair.
Definition: SGImplSvc.cxx:1491
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
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::DataProxy::accessData
DataObject * accessData()
Access DataObject on-demand using conversion service.
SGImplSvc::m_newBoundHandles
std::map< std::thread::id, std::vector< IResetable * > > m_newBoundHandles
Keep track of proxies bound since the last call to commitNewDataObjects or clearStore.
Definition: SGImplSvc.h:725
SG::CurrentEventStore::setStore
static IProxyDict * setStore(IProxyDict *store)
Set the current store.
Definition: CurrentEventStore.cxx:36
SGImplSvc::proxyRange
StatusCode proxyRange(const CLID &id, SG::ConstProxyIterator &beg, SG::ConstProxyIterator &end) const
return a range to all proxies of a given CLID
Definition: SGImplSvc.cxx:1329
CLIDRegistry::CLIDToTypeinfo
static const std::type_info * CLIDToTypeinfo(CLID clid)
Translate between CLID and type_info.
Definition: CLIDRegistry.cxx:136
SGImplSvc::m_stringPoolMutex
mutex_t m_stringPoolMutex
Definition: SGImplSvc.h:731
SGImplSvc::m_pIncSvc
ServiceHandle< IIncidentSvc > m_pIncSvc
property
Definition: SGImplSvc.h:695
get_generator_info.stderr
stderr
Definition: get_generator_info.py:40
SGImplSvc::emptyTrash
void emptyTrash()
throw away bad objects
Definition: SGImplSvc.cxx:1380
SG::asStorable
DataObject * asStorable(T *pObject)
Definition: StorableConversions.h:158
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
SGImplSvc::releaseObject
void releaseObject(const CLID &id, const std::string &key)
release object held by proxy, if any.
Definition: SGImplSvc.cxx:1580
SG::DataProxy::isValid
bool isValid() const
called by destructor
PyPoolBrowser.dh
dh
Definition: PyPoolBrowser.py:102
SGImplSvc::proxies
virtual std::vector< const SG::DataProxy * > proxies() const override final
return the list of all current proxies in store
Definition: SGImplSvc.cxx:969
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
SGImplSvc::reinitialize
virtual StatusCode reinitialize() override final
Service reinitialization.
Definition: SGImplSvc.cxx:324
Args
Definition: test_lwtnn_fastgraph.cxx:12
IStringPool::sgkey_t
SG::sgkey_t sgkey_t
Type of the keys.
Definition: IStringPool.h:34
SG::RemapImpl
Definition: SGImplSvc.cxx:85
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
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
SGImplSvc::sourceID
virtual SG::SourceID sourceID(const std::string &key="EventSelector") const override
Return the metadata source ID for the current event slot.
Definition: SGImplSvc.cxx:1866
SG::VersionedKey::isAuto
static bool isAuto(const std::string &)
quickly determine whether a string has the right format to be a VK with auto-generated version #
Definition: SGVersionedKey.cxx:28
IProxyDict
A proxy dictionary.
Definition: AthenaKernel/AthenaKernel/IProxyDict.h:47
SG::DataStore::setStoreID
void setStoreID(StoreID::type id)
Definition: Control/SGTools/SGTools/DataStore.h:92
AuxVectorBase.h
Manage index tracking and synchronization of auxiliary data.
AthenaPoolTestWrite.stream
string stream
Definition: AthenaPoolTestWrite.py:12
SG::detail::IteratorBase::setState
StatusCode setState(SG::ConstProxyIterator itr, SG::ConstProxyIterator itrEnd, bool isConst)
Reset state of the iterator.
Definition: SGIterator.cxx:94
SG::AuxVectorBase
Manage index tracking and synchronization of auxiliary data.
Definition: AuxVectorBase.h:98
SGImplSvc::m_ActivateHistory
bool m_ActivateHistory
Activate the history service.
Definition: SGImplSvc.h:697
SG::Arena::makeCurrent
ArenaBase * makeCurrent()
Make this Arena the current one for its ArenaHeader.
Definition: Arena.cxx:59
SG::DataProxy::CLIDCont_t
TransientAddress::TransientClidSet CLIDCont_t
Definition: DataProxy.h:53
SGImplSvc::m_storeLoaded
bool m_storeLoaded
FIXME hack needed by loadEventProxies.
Definition: SGImplSvc.h:706
SG::ArenaBase::report
void report(std::ostream &os) const
Generate a report of the memory in use by this Arena.
Definition: ArenaBase.cxx:76
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SGImplSvc::m_slotNumber
int m_slotNumber
The Hive slot number for this store, or -1 if this isn't a Hive store.
Definition: SGImplSvc.h:716
SGImplSvc::keyToString
virtual const std::string * keyToString(sgkey_t key) const override final
Find the string corresponding to a given key.
Definition: SGImplSvc.cxx:1505
SG::StringPool::clear
void clear()
Empty the pool.
Definition: StringPool.cxx:350
SGImplSvc::initialize
virtual StatusCode initialize() override final
Service initialization.
Definition: SGImplSvc.cxx:147
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
SGImplSvc::typeless_overwrite
StatusCode typeless_overwrite(const CLID &id, DataObject *obj, const std::string &key, const void *const raw_ptr, bool allowMods, bool noHist=false, const std::type_info *tinfo=0)
same as typeless_record, allows to overwrite an object in memory or on disk
Definition: SGImplSvc.cxx:1098
SG::RemapImpl::m_remaps
remap_map_t m_remaps
Definition: SGImplSvc.cxx:93
SGImplSvc::bindHandleToProxyAndRegister
bool bindHandleToProxyAndRegister(const CLID &id, const std::string &key, IResetable *ir, SG::DataProxy *&dp)
Also do registration with IOVSvc.
Definition: SGImplSvc.cxx:1423
SGImplSvc::storeID
StoreID::type storeID() const
get store ID. request forwarded to DataStore:
Definition: SGImplSvc.cxx:510
SGImplSvc::unboundHandle
virtual void unboundHandle(IResetable *handle) override final
Tell the store that a handle has been unbound from a proxy.
Definition: SGImplSvc.cxx:1803
SG::DataStore::proxy_exact
SG::DataProxy * proxy_exact(sgkey_t sgkey) const
get proxy with given key.
Definition: Control/SGTools/src/DataStore.cxx:524
DiTauMassTools::ignore
void ignore(T &&)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:58
SGImplSvc::m_pStore
SG::DataStore * m_pStore
Definition: SGImplSvc.h:692
IResetable
a resetable object (e.g. a SG DataHandle)
Definition: IResetable.h:15
ArenaHeader.h
Proxy for a group of Arenas. See Arena.h for an overview of the arena-based memory allocators.
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
python.UpdateManyBadChannelIOVs.toRemove
tuple toRemove
Definition: UpdateManyBadChannelIOVs.py:87
SGImplSvc::m_pDataLoader
ServiceHandle< IConversionSvc > m_pDataLoader
Definition: SGImplSvc.h:683
SGImplSvc::m_DumpStore
bool m_DumpStore
Dump Property flag: triggers dump() at EndEvent.
Definition: SGImplSvc.h:696
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
SGImplSvc::clids
std::vector< CLID > clids() const
Return all CLIDs in the store.
Definition: SGImplSvc.cxx:979
DataHeader
This class provides the layout for summary information stored for data written to POOL.
Definition: DataHeader.h:124
lumiFormat.i
int i
Definition: lumiFormat.py:85
SG::ArenaHeader
Proxy for a group of Arenas.
Definition: ArenaHeader.h:54
SGImplSvc::bindHandleToProxy
bool bindHandleToProxy(const CLID &id, const std::string &key, IResetable *ir, SG::DataProxy *&dp)
name says it all
Definition: SGImplSvc.cxx:1391
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
SGImplSvc::sgkey_t
IStringPool::sgkey_t sgkey_t
Definition: SGImplSvc.h:354
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SG::ArenaBase::reset
void reset()
Reset all contained allocators.
Definition: ArenaBase.cxx:44
SGImplSvc::m_arena
SG::Arena m_arena
Allocation arena to associate with this store.
Definition: SGImplSvc.h:713
SG::DataProxy::alias
AliasCont_t alias() const
access set of proxy aliases Returns a COPY of the alias set.
SGImplSvc.h
SG::VersionedKey
a StoreGateSvc key with a version number. Notice that StoreGate does not order multiple instances of ...
Definition: SGVersionedKey.h:31
SGImplSvc::m_stringpool
SG::StringPool m_stringpool
Definition: SGImplSvc.h:708
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:40
StringPool.h
Maintain a mapping of strings to 64-bit ints.
SGImplSvc::accessData
DataObject * accessData(const CLID &id) const
find proxy and access its data. Returns 0 to flag failure
Definition: SGImplSvc.cxx:1008
SG::DataStore::addSymLink
StatusCode addSymLink(const CLID &linkid, DataProxy *proxy)
add symlink to store:
Definition: Control/SGTools/src/DataStore.cxx:330
SGImplSvc::clearProxyPayload
void clearProxyPayload(SG::DataProxy *)
use to reset a proxy (clearing the data object it contains) Unlike DataProxy::reset this method corre...
Definition: SGImplSvc.cxx:1597
SGImplSvc::setupProxy
SG::DataProxy * setupProxy(const CLID &dataID, const std::string &gK, DataObject *pDObj, bool allowMods, bool resetOnly)
try to locate a proxy or create it if needed
Definition: SGImplSvc.cxx:462
IOVSvcCallBackFcn
boost::function< StatusCode(IOVSVC_CALLBACK_ARGS) > IOVSvcCallBackFcn
the type of an IOVSvc call back: it wraps both the method and the object the method is called on
Definition: IOVSvcDefs.h:58
SG::BaseInfoBase::get_copy_conversions
std::vector< CLID > get_copy_conversions() const
Return known copy conversions.
Definition: BaseInfo.cxx:455
SGImplSvc
The Athena Transient Store API.
Definition: SGImplSvc.h:112
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
hist_file_dump.f
f
Definition: hist_file_dump.py:135
SGImplSvc::transientContains
bool transientContains(const CLID id, const std::string &key) const
Look up a transient data object in TDS only by CLID.
Definition: SGImplSvc.cxx:744
SGImplSvc::m_pHistorySvc
ServiceHandle< IHistorySvc > m_pHistorySvc
Definition: SGImplSvc.h:690
SG::StringPool::keyToString
const std::string * keyToString(sgkey_t key) const
Find the string corresponding to a given key.
Definition: StringPool.cxx:286
Handler::svc
AthROOTErrorHandlerSvc * svc
Definition: AthROOTErrorHandlerSvc.cxx:10
SGImplSvc::remove
StatusCode remove(const void *pObject)
Remove pObject, will remove its proxy if not reset only.
Definition: SGImplSvc.cxx:1356
SGImplSvc::remap_impl
void remap_impl(sgkey_t source, sgkey_t target, off_t index_offset)
Declare a remapping.
Definition: SGImplSvc.cxx:1625
SG::ArenaBase::erase
void erase()
Erase all contained allocators.
Definition: ArenaBase.cxx:60
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
SGImplSvc::record_impl
SG::DataProxy * record_impl(DataObject *obj, const std::string &key, const void *const raw_ptr, bool allowMods, bool resetOnly, bool allowOverwrite, const std::type_info *tinfo)
real recording of an object with a key, allow possibility of specifying const-access
Definition: SGImplSvc.cxx:1133
SGImplSvc::tryELRemap
virtual bool tryELRemap(sgkey_t sgkey_in, size_t index_in, sgkey_t &sgkey_out, size_t &index_out) override final
Test to see if the target of an ElementLink has moved.
Definition: SGImplSvc.cxx:1645
DataHeader.h
This file contains the class definition for the DataHeader and DataHeaderElement classes.
WriteCalibToCool.swap
swap
Definition: WriteCalibToCool.py:94
IProxyProviderSvc::preLoadProxies
virtual StatusCode preLoadProxies(IProxyRegistry &dataStore)=0
add proxies to the store before Begin Event:
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.
SGImplSvc::~SGImplSvc
virtual ~SGImplSvc() override final
Standard Destructor.
Definition: SGImplSvc.cxx:137
StoreID::DETECTOR_STORE
@ DETECTOR_STORE
Definition: StoreID.h:27
SGImplSvc::msg_update_handler
void msg_update_handler(Gaudi::Details::PropertyBase &outputLevel)
callback for output level property
Definition: SGImplSvc.cxx:1321
StoreID.h
SGImplSvc::finalize
virtual StatusCode finalize() override final
Service finalization.
Definition: SGImplSvc.cxx:303
SG::DataProxy_cast
DATA * DataProxy_cast(DataProxy *proxy)
cast the proxy into the concrete data object it proxies
IProxyProviderSvc::retrieveProxy
virtual SG::DataProxy * retrieveProxy(const CLID &id, const std::string &key, IProxyRegistry &dataStore)=0
Use a provider to create a proxy for ID/KEY.
SGImplSvc::recordAddress
StatusCode recordAddress(const std::string &skey, IOpaqueAddress *pAddress, bool clearAddressFlag=true)
Create a proxy object using an IOpaqueAddress and a transient key.
Definition: SGImplSvc.cxx:371
SGImplSvc::retrieve
StatusCode retrieve(CLID clid, SG::detail::IteratorBase &cibegin, SG::detail::IteratorBase &ciend) const
Retrieve all objects of type T: returns an SG::ConstIterator range.
Definition: SGImplSvc.cxx:1884
SG::DataStore::storeID
virtual StoreID::type storeID() const
Definition: Control/SGTools/SGTools/DataStore.h:93
SGImplSvc::dump
std::string dump() const
dump objects in store.
Definition: SGImplSvc.cxx:557
SGImplSvc::registerKey
virtual void registerKey(sgkey_t key, const std::string &str, CLID clidid) override final
Remember an additional mapping from key to string/CLID.
Definition: SGImplSvc.cxx:1540
SGImplSvc::setStoreID
void setStoreID(StoreID::type id)
set store ID. request forwarded to DataStore:
Definition: SGImplSvc.cxx:504
dbg
Definition: SGImplSvc.cxx:69
SGImplSvc::typeCount
int typeCount(const CLID &id) const
Return the number of instances of type T (input CLID)
Definition: SGImplSvc.cxx:727
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:225
SGImplSvc::record_HistObj
StatusCode record_HistObj(const CLID &id, const std::string &key, const std::string &store, bool allowMods, bool resetOnly=true)
Definition: SGImplSvc.cxx:1457
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
SG::BaseInfoBase::find
static const BaseInfoBase * find(CLID clid)
Find the BaseInfoBase instance for clid.
Definition: BaseInfo.cxx:569
SGImplSvc::removeDataAndProxy
StatusCode removeDataAndProxy(const void *pObject)
Remove pObject and its proxy no matter what.
Definition: SGImplSvc.cxx:1365
SGImplSvc::recycle
void recycle(DataObject *pBadDObj)
put a bad (unrecordable) dobj away
Definition: SGImplSvc.cxx:1373
SGImplSvc::m_DumpArena
bool m_DumpArena
DumpArena Property flag : trigger m_arena->report() at clearStore.
Definition: SGImplSvc.h:698
errorcheck.h
Helpers for checking error return status codes and reporting errors.
SG::DataStore::keys
void keys(const CLID &id, std::vector< std::string > &vkeys, bool includeAlias, bool onlyValid)
Definition: Control/SGTools/src/DataStore.cxx:118
SGImplSvc::clid
CLID clid(const std::string &key) const
Retrieve the main CLID of the object recorded in StoreGate with the given "key" WARNING: slow!
Definition: SGImplSvc.cxx:1676
SGImplSvc::typeless_record
StatusCode typeless_record(DataObject *obj, const std::string &key, const void *const raw_ptr, bool allowMods, bool resetOnly=true, bool noHist=false)
type-less recording of an object with a key, allow possibility of specifying const-access and history...
Definition: SGImplSvc.cxx:1050
SG::VersionedKey::rawVersionKey
const std::string & rawVersionKey() const
Definition: SGVersionedKey.h:76
SG::RemapImpl::remap_t::index_offset
off_t index_offset
Definition: SGImplSvc.cxx:90
SG::sgkey_t
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition: CxxUtils/CxxUtils/sgkey_t.h:32
IHiveStoreMgr
the interface through which HiveWB control StoreGate instances
Definition: IHiveStoreMgr.h:24
StoreClearedIncident.h
Incident sent after a store is cleared.
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
SGImplSvc::queryInterface
virtual StatusCode queryInterface(const InterfaceID &riid, void **ppvInterface) override final
Definition: SGImplSvc.cxx:343
SGImplSvc::interfaceID
static const InterfaceID & interfaceID()
Should rather be in ISGImplSvc.h if we had one.
Definition: SGImplSvc.cxx:333
SGImplSvc::m_numSlots
int m_numSlots
The total number of slots. 1 if this isn't a Hive store.
Definition: SGImplSvc.h:719
SGImplSvc::symLink
StatusCode symLink(const void *p2BRegistered, CLID linkID)
make a soft link to the object T* already registered
Definition: SGImplSvc.cxx:612
PixelModuleFeMask_create_db.payload
string payload
Definition: PixelModuleFeMask_create_db.py:69
SGImplSvc::addToStore
virtual StatusCode addToStore(CLID id, SG::DataProxy *proxy) override final
Raw addition of a proxy to the store.
Definition: SGImplSvc.cxx:829
SGImplSvc::m_pCLIDSvc
ServiceHandle< IClassIDSvc > m_pCLIDSvc
Definition: SGImplSvc.h:682
SGImplSvc::addAlias
StatusCode addAlias(const std::string &aliasKey, SG::DataProxy *dp)
Definition: SGImplSvc.cxx:715
REPORT_MESSAGE
#define REPORT_MESSAGE(LVL)
Report a message.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:365
IIOVSvc.h
SGImplSvc::handle
virtual void handle(const Incident &) override final
triggered by Incident service
Definition: SGImplSvc.cxx:232
python.TrigPSCPythonDbSetup.outputLevel
outputLevel
Definition: TrigPSCPythonDbSetup.py:30
SG::IAuxStore
Interface for non-const operations on an auxiliary store.
Definition: IAuxStore.h:48
SG::VersionedKey::key
const std::string & key() const
Definition: SGVersionedKey.cxx:71
CLIDRegistry.h
a static registry of CLID->typeName entries. NOT for general use. Use ClassIDSvc instead.
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:67
ir
int ir
counter of the current depth
Definition: fastadd.cxx:49
python.PyAthena.v
v
Definition: PyAthena.py:154
SG::DataProxy::isValidObject
bool isValidObject() const
is the object valid?
SG::ArenaHeader::defaultHeader
static ArenaHeader * defaultHeader()
Return the global default Header instance.
Definition: ArenaHeader.cxx:164
python.DataFormatRates.c2
c2
Definition: DataFormatRates.py:123
SGImplSvc::transientProxy
SG::DataProxy * transientProxy(const CLID &id, const std::string &key) const
get proxy with given id and key.
Definition: SGImplSvc.cxx:1000
fmt
a
TList * a
Definition: liststreamerinfos.cxx:10
SG::DataProxy::reset
void reset(bool hard=false)
Other methods of DataProxy (not in Interface IRegistry):
Definition: DataProxy.cxx:240
InDetDD::other
@ other
Definition: InDetDD_Defs.h:16
SGImplSvc::m_pIOVSvc
ServiceHandle< IIOVSvc > m_pIOVSvc
get the IOVSvc "just in time" (breaks recursion at initialize)
Definition: SGImplSvc.h:704
h
SGImplSvc::makeCurrent
void makeCurrent()
The current store is becoming the active store.
Definition: SGImplSvc.cxx:1815
SG::DataProxy::transientID
bool transientID(CLID id) const
return the list of transient IDs (primary or symLinked):
SGImplSvc::m_trash
std::list< DataObject * > m_trash
The Recycle Bin.
Definition: SGImplSvc.h:693
StoreID::type
type
Definition: StoreID.h:24
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
copySelective.target
string target
Definition: copySelective.py:37
TransientAddress.h
StoreID::findStoreID
static StoreID::type findStoreID(const std::string &storeName)
Definition: StoreID.cxx:21
SG::SourceID
std::string SourceID
Definition: AthenaKernel/AthenaKernel/SourceID.h:23
python.TriggerHandler.verbose
verbose
Definition: TriggerHandler.py:297
DeMoScan.first
bool first
Definition: DeMoScan.py:536
DEBUG
#define DEBUG
Definition: page_access.h:11
SG::SGKeyMap
std::unordered_map< sgkey_t, T > SGKeyMap
A map using sgkey_t as a key.
Definition: CxxUtils/CxxUtils/sgkey_t.h:93
SG::BaseInfoBase
The non-template portion of the BaseInfo implementation.
Definition: Control/AthenaKernel/AthenaKernel/BaseInfo.h:451
SG::DataStore::t2pRemove
void t2pRemove(const void *const pTrans)
Definition: Control/SGTools/SGTools/DataStore.h:256
SG::detail::IteratorBase
Definition: SGIterator.h:36
SGImplSvc::store
SG::DataStore * store()
Definition: SGImplSvc.cxx:597
SGImplSvc::stop
virtual StatusCode stop() override final
Service stop.
Definition: SGImplSvc.cxx:214
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
IAuxStore.h
Interface for non-const operations on an auxiliary store.
SGImplSvc::m_pPPS
IProxyProviderSvc * m_pPPS
Definition: SGImplSvc.h:688
DataBucketBase::relinquish
virtual void relinquish()=0
Give up ownership of the DataBucket contents.
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
SGImplSvc::lock_t
std::lock_guard< mutex_t > lock_t
Definition: SGImplSvc.h:728
IProxyProviderSvc.h
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::StringPool::merge
bool merge(const StringPool &other)
Merge another pool into this one.
Definition: StringPool.cxx:363
copySelective.source
string source
Definition: copySelective.py:32
str
Definition: BTagTrackIpAccessor.cxx:11
SGImplSvc::setSlotNumber
void setSlotNumber(int slot, int numSlots)
Set the Hive slot number for this store.
Definition: SGImplSvc.cxx:958
dbg::print
void print(std::FILE *stream, std::format_string< Args... > fmt, Args &&... args)
Definition: SGImplSvc.cxx:70
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
StoreID::EVENT_STORE
@ EVENT_STORE
Definition: StoreID.h:26
SG::DataObjectSharedPtr
Smart pointer to manage DataObject reference counts.
Definition: DataObjectSharedPtr.h:46
SGImplSvc::createKey
std::string createKey(const CLID &dataID)
creates a key internally if none specified by client
Definition: SGImplSvc.cxx:262
SGImplSvc::proxy_exact
virtual SG::DataProxy * proxy_exact(SG::sgkey_t sgkey) const override final
Get proxy given a hashed key+clid.
Definition: SGImplSvc.cxx:946
SG::StringPool::stringToKey
sgkey_t stringToKey(const std::string &str, sgaux_t aux=0)
Find the key for a string.
Definition: StringPool.cxx:248
IConstAuxStore.h
Interface for const operations on an auxiliary store.
SG::RemapImpl::remap_t
Definition: SGImplSvc.cxx:88
get_generator_info.error
error
Definition: get_generator_info.py:40
SG::IConstAuxStore
Interface for const operations on an auxiliary store.
Definition: IConstAuxStore.h:64
SGImplSvc::m_mutex
mutex_t m_mutex
Definition: SGImplSvc.h:729
checker_macros.h
Define macros for attributes used to control the static checker.
SGImplSvc::t2pRemove
void t2pRemove(const void *const pTrans)
forwarded to DataStore
Definition: SGImplSvc.cxx:1315
python.PyAthena.obj
obj
Definition: PyAthena.py:132
SGImplSvc::m_pPPSHandle
ServiceHandle< IProxyProviderSvc > m_pPPSHandle
Definition: SGImplSvc.h:685
SG::DataProxy
Definition: DataProxy.h:44
SGImplSvc::regFcn
StatusCode regFcn(const CallBackID &c1, const CallBackID &c2, const IOVSvcCallBackFcn &fcn, bool trigger=false)
register a callback function(2) with an already registered function(1)
Definition: SGImplSvc.cxx:534
SGImplSvc::start
virtual StatusCode start() override final
Service start.
Definition: SGImplSvc.cxx:199
SGImplSvc::proxy
virtual SG::DataProxy * proxy(const void *const pTransient) const override final
get proxy for a given data object address in memory
Definition: SGImplSvc.cxx:753
SGImplSvc::isSymLinked
bool isSymLinked(const CLID &linkID, SG::DataProxy *dp)
Definition: SGImplSvc.cxx:527
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
SG::DataStore::tRange
StatusCode tRange(ConstStoreIterator &f, ConstStoreIterator &e) const
Return an iterator over the StoreMap:
Definition: Control/SGTools/src/DataStore.cxx:596
SGImplSvc::t2pRegister
StatusCode t2pRegister(const void *const pTrans, SG::DataProxy *const pPers)
forwarded to DataStore
Definition: SGImplSvc.cxx:1308
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::RemapImpl::remap_map_t
SGKeyMap< remap_t > remap_map_t
Definition: SGImplSvc.cxx:92
StoreGateSvc.h
python.compressB64.c
def c
Definition: compressB64.py:93
SG::ArenaBase::name
const std::string & name() const
Return this Arena's name.
Definition: ArenaBase.cxx:114
SGImplSvc::typeless_retrievePrivateCopy
DataObject * typeless_retrievePrivateCopy(const CLID clid, const std::string &key)
Definition: SGImplSvc.cxx:1660
SG::ConstProxyIterator
ProxyMap::const_iterator ConstProxyIterator
Definition: ProxyMap.h:28
python.CaloScaleNoiseConfig.args
args
Definition: CaloScaleNoiseConfig.py:80
SG::StringPool::registerKey
bool registerKey(sgkey_t key, const std::string &str, sgaux_t aux=0)
Remember an additional mapping from key to string.
Definition: StringPool.cxx:319
SGImplSvc::addAutoSymLinks
void addAutoSymLinks(const std::string &key, CLID clid, SG::DataProxy *dp, const std::type_info *tinfo, bool warn_nobib=true)
Add automatically-made symlinks for DP.
Definition: SGImplSvc.cxx:1710
SGImplSvc::m_remap_impl
SG::RemapImpl * m_remap_impl
Definition: SGImplSvc.h:710
SGImplSvc::transientSwap
bool transientSwap(const CLID &id, const std::string &keyA, const std::string &keyB)
swap the content of 2 keys payload A indexed by keyA will now be accessed via keyB and vice versa Not...
Definition: SGImplSvc.cxx:1024
SGImplSvc::keys
void keys(const CLID &id, std::vector< std::string > &vkeys, bool includeAlias=false, bool onlyValid=true)
provide list of all StoreGate keys associated with an object.
Definition: SGImplSvc.cxx:518
SGImplSvc::m_remapMutex
mutex_t m_remapMutex
Definition: SGImplSvc.h:730
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
SGImplSvc::loadEventProxies
StatusCode loadEventProxies()
load proxies at begin event
Definition: SGImplSvc.cxx:243
DataProxy.h