ATLAS Offline Software
StoreGateSvc.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "GaudiKernel/IIncidentSvc.h"
9 
10 #include "StoreGate/StoreGateSvc.h"
12 #include "SGTools/DataStore.h"
13 
14 #include "Gaudi/Interfaces/IOptionsSvc.h"
15 #include "GaudiKernel/IAppMgrUI.h"
16 #include <fstream>
17 #include <algorithm>
18 
19 using namespace SG;
20 using namespace std;
21 
22 namespace {
23  thread_local HiveEventSlot* currentHiveEventSlot = nullptr;
24  thread_local StoreGateSvc* currentStoreGate = nullptr;
25 }
26 
28 StoreGateSvc::StoreGateSvc(const std::string& name,ISvcLocator* svc) :
29  base_class(name,svc),
30  m_storeID (StoreID::findStoreID(name))
31 {
32 }
33 
36 {}
37 
38 void
40  m_defaultStore = pStore;
41 }
42 
43 void
45  currentHiveEventSlot=pSlot;
46  if ( 0 != currentHiveEventSlot) {
47  currentHiveEventSlot->pEvtStore->makeCurrent();
48  }
49 }
50 
52  if (!::currentStoreGate) {
53  // this is a static function so we don't have many conveniences
54  ISvcLocator *svcLocator = Gaudi::svcLocator();
55  SmartIF<StoreGateSvc> sg{svcLocator->service("StoreGateSvc/StoreGateSvc")};
56  if ( !sg.isValid() ) {
57  throw GaudiException(
58  "Could not get \"StoreGateSvc\" to initialize currentStoreGate",
59  "StoreGateSvc", StatusCode::FAILURE);
60  }
61  sg->makeCurrent();
62  return sg;
63  }
64  return ::currentStoreGate;
65 }
66 
69  return currentHiveEventSlot;
70 }
71 
73 
74 
75 void
77  _SGVOIDCALL(commitNewDataObjects, ());
78 }
79 
82 StoreGateSvc::recordAddress(const std::string& skey,
83  IOpaqueAddress* pAddress, bool clearAddressFlag) {
84  _SGXCALL(recordAddress, (skey, pAddress, clearAddressFlag), StatusCode::FAILURE);
85 }
88 StoreGateSvc::recordAddress(IOpaqueAddress* pAddress, bool clearAddressFlag) {
89  _SGXCALL(recordAddress, (pAddress, clearAddressFlag), StatusCode::FAILURE);
90 }
91 
92 
94 StoreGateSvc::setConst(const void* pObject) {
95  _SGXCALL(setConst, (pObject), StatusCode::FAILURE);
96 }
97 
98 
102 
103  // Initialize service:
105 
106  verbose() << "Initializing " << name() << endmsg;
107 
108  SmartIF<Gaudi::Interfaces::IOptionsSvc> pJOSvc{serviceLocator()->service("JobOptionsSvc")};
109  if ( !pJOSvc.isValid() ) {
110  error() << "Failed to retrieve JobOptionsSvc" << endmsg;
111  }
112  //copy our properties to the prototype (default) SGImplSvc
113  const std::string implStoreName = name() + "_Impl";
114  for (const Gaudi::Details::PropertyBase* p : getProperties()) {
115  pJOSvc->set( implStoreName + "." + p->name(), p->toString() );
116  }
117 
118  //HACK ALERT: using createService rather then the customary service(...,CREATEIF=true) we set our pointer
119  // to SGImplSvc early (even before it is initialized). This should help take care of some initialize loops
120  // for example when we try to record an address from one of the address providers initialize methods
121 
122  std::string implStoreFullName = "SGImplSvc/" + implStoreName;
123  debug() << "trying to create store " << implStoreFullName << endmsg;
124 
125  m_defaultStore = serviceLocator().as<ISvcManager>()->createService(implStoreFullName);
126 
127  if (!m_defaultStore) {
128  error() << "Could not create store " << implStoreFullName << endmsg;
129  return StatusCode::FAILURE;
130  }
131 
132  if ( m_defaultStore->sysInitialize().isSuccess() ) {
133  // If this is the default event store (StoreGateSvc), then declare
134  // our arena as the default for memory allocations.
135  if (name() == "StoreGateSvc") {
136  m_defaultStore->makeCurrent();
137  }
138  } else {
139  error() << "Could not initialize default store " << implStoreFullName
140  << endmsg;
141  return StatusCode::FAILURE;
142  }
143  if ( !m_incSvc.retrieve().isSuccess() ) {
144  error() << "Could not locate IncidentSvc" << endmsg;
145  return StatusCode::FAILURE;
146  }
147 
148  // Don't retrieve m_activeStoreSvc here to prevent a possible
149  // initialization loop.
150 
151  const int PRIORITY=100;
152  m_incSvc->addListener(this, "EndEvent",PRIORITY);
153  m_incSvc->addListener(this, "BeginEvent", PRIORITY);
154 
155  return StatusCode::SUCCESS;
156 }
157 
160  verbose() << "Stop " << name() << endmsg;
161  //HACK ALERT: ID event store objects refer to det store objects
162  //by setting an ad-hoc priority for event store(s) we make sure they are finalized and hence cleared first
163  // see e.g. https://savannah.cern.ch/bugs/index.php?99993
164  if (m_defaultStore->store()->storeID() == StoreID::EVENT_STORE) {
165  auto pISM = serviceLocator().as<ISvcManager>();
166  pISM->setPriority(name(), pISM->getPriority(name())+1).ignore();
167  verbose() << "stop: setting service priority to " << pISM->getPriority(name())
168  << " so that event stores get finalized and cleared before other stores" <<endmsg;
169  }
170  return StatusCode::SUCCESS;
171 }
172 
173 void StoreGateSvc::handle(const Incident &inc) {
174  currentStore()->handle(inc);
175 }
176 
178 
182  verbose() << "Finalizing " << name() << endmsg;
183  if (m_defaultStore) {
184  // m_defaultStore is not active, so ServiceManager won't finalize it!
185  CHECK( m_defaultStore->finalize());
186  }
187 
188  printBadList (m_badRetrieves, "retrieve()");
189  printBadList (m_badRecords, "record()");
190  return StatusCode::SUCCESS;
191 }
192 
193 
195 DataProxy*
196 StoreGateSvc::proxy(const void* const pTransient) const {
197  _SGXCALL(proxy, (pTransient), 0);
198 }
199 
201 DataProxy*
202 StoreGateSvc::proxy(const CLID& id) const {
203  _SGXCALL(proxy, (id), 0);
204 }
205 
207 DataProxy*
208 StoreGateSvc::proxy(const CLID& id, const std::string& key) const {
209  _SGXCALL(proxy, (id, key), 0);
210 }
211 
212 
216 StoreGateSvc::proxy(const CLID& id, bool checkValid) const {
217  _SGXCALL(proxy, (id, checkValid), 0);
218 }
219 
223 StoreGateSvc::proxy(const CLID& id, const std::string& key, bool checkValid) const {
224  _SGXCALL(proxy, (id, key, checkValid), 0);
225 }
226 
227 
234 {
235  _SGXCALL(addToStore, (id, proxy), StatusCode::FAILURE);
236 }
237 
238 
261  const std::string& key,
262  bool allowMods,
263  bool returnExisting)
264 {
265  _SGXCALL(recordObject, (std::move(obj), key, allowMods, returnExisting), nullptr);
266 }
267 
268 
270 vector<const SG::DataProxy*>
272  vector<const SG::DataProxy*> nullV;
273  _SGXCALL(proxies, (), nullV);
274 }
275 
277 vector<CLID>
279 {
280  vector<CLID> nullV;
281  _SGXCALL(clids, (), nullV);
282 }
283 
287 StoreGateSvc::transientProxy(const CLID& id, const std::string& key) const {
288  _SGXCALL(transientProxy, (id, key), 0);
289 }
290 
291 
293 DataObject*
294 StoreGateSvc::accessData(const CLID& id) const {
295  _SGXCALL(accessData, (id), 0);
296 }
297 
299 DataObject*
300 StoreGateSvc::accessData(const CLID& id, const std::string& key) const {
301  _SGXCALL(accessData, (id, key), 0);
302 }
303 
304 bool
306  const std::string& keyA, const std::string& keyB ) {
307  _SGXCALL(transientSwap, (id, keyA, keyB), false);
308 }
309 
312 StatusCode
313 StoreGateSvc::typeless_record( DataObject* obj, const std::string& key,
314  const void* const raw_ptr,
315  bool allowMods, bool resetOnly,
316  bool noHist ) {
317  _SGXCALL(typeless_record, (obj, key, raw_ptr, allowMods, resetOnly, noHist), StatusCode::FAILURE);
318 }
320 StatusCode
322  DataObject* obj, const std::string& key,
323  const void* const raw_ptr,
324  bool allowMods,
325  bool noHist,
326  const std::type_info* tinfo) {
327  _SGXCALL(typeless_overwrite, (id, obj, key, raw_ptr, allowMods, noHist, tinfo), StatusCode::FAILURE);
328 }
329 
331 void
333 {
334  m_storeID = id;
335  // FIXME: should broadcast this to all instances.
336  _SGVOIDCALL(setStoreID,(id));
337 }
338 
339 void
340 StoreGateSvc::keys(const CLID& id, std::vector<std::string>& vkeys,
341  bool includeAlias, bool onlyValid) const
342 {
343  _SGVOIDCALL(keys,(id, vkeys, includeAlias, onlyValid));
344 }
345 
346 
347 
348 std::string
350  std::string nullS = "\n>>>>>>>NO CURRENT STORE<<<<<<<\n";
351  _SGXCALL(dump, (), nullS);
352 }
353 
354 int
355 StoreGateSvc::typeCount(const CLID& clid) const{
356  _SGXCALL(typeCount, (clid), -1);
357 }
358 
359 
360 
361 typename StoreGateSvc::sgkey_t
362 StoreGateSvc::stringToKey (const std::string& str, CLID clid) {
363  _SGXCALL( stringToKey, (str, clid), 0 );
364 }
365 
366 const std::string*
368  _SGXCALL( keyToString, (key), 0 );
369 }
370 
371 const std::string*
372 StoreGateSvc::keyToString (sgkey_t key, CLID& clid) const {
373  _SGXCALL( keyToString, (key, clid), 0 );
374 }
375 
376 void
378  const std::string& str,
379  CLID clidid) {
380  _SGVOIDCALL( registerKey, (key, str, clidid) );
381 }
382 void
384  sgkey_t target,
385  off_t index_offset) {
386  _SGVOIDCALL( remap_impl, (source, target, index_offset) );
387 }
388 
389 bool
390 StoreGateSvc::tryELRemap (sgkey_t sgkey_in, size_t index_in,
391  sgkey_t& sgkey_out, size_t& index_out) {
392  _SGXCALL( tryELRemap, (sgkey_in, index_in, sgkey_out, index_out), false );
393 }
394 
395 StatusCode
398  SG::ConstProxyIterator& end) const {
399  _SGXCALL( proxyRange, (id, beg, end), StatusCode::FAILURE );
400 }
401 
402 
403 void
404 StoreGateSvc::releaseObject(const CLID& id, const std::string& key) {
405  _SGVOIDCALL( releaseObject, (id, key) );
406 }
407 
408 void
410  _SGVOIDCALL( clearProxyPayload, (proxy) );
411 }
412 
413 
414 StatusCode
416  this->makeCurrent();
417  _SGXCALL(loadEventProxies, (), StatusCode::FAILURE);
418 }
419 
421 // clear store
422 StatusCode
423 StoreGateSvc::clearStore(bool forceRemove)
424 {
425  StatusCode sc = currentStore()->clearStore(forceRemove);
426 
427  // Send a notification that the store was cleared.
428  if (sc.isSuccess()) {
429  m_incSvc->fireIncident(StoreClearedIncident (this, name()));
430  }
431  return sc;
432 }
433 
434 void
436  _SGVOIDCALL( emptyTrash, () );
437 }
438 
443  ::currentStoreGate = this;
444  _SGVOIDCALL (makeCurrent, ());
445 }
446 
448  bool forceRemove) {
449  _SGXCALL(removeProxy, (proxy, pTrans, forceRemove), StatusCode::FAILURE);
450 }
451 
452 
464 StoreGateSvc::createObj (IConverter* cvt,
465  IOpaqueAddress* addr,
466  DataObject*& refpObject)
467 {
468  _SGXCALL( createObj, (cvt, addr, refpObject), StatusCode::FAILURE );
469 }
470 
471 
479  CLID clid, const std::string& key) const
480 {
481  if (m_storeID == StoreID::EVENT_STORE && currentHiveEventSlot != nullptr) {
482  lock_t lock (m_badMutex);
483  std::string algo;
484  if (m_algContextSvc.isValid()) {
485  if (IAlgorithm* alg = m_algContextSvc->currentAlg()) {
486  if (alg->type() == "AthenaOutputStream") return;
487  if (alg->type() == "AthIncFirerAlg") return;
488  algo = alg->type() + "/" + alg->name();
489  bad.insert (BadListItem (clid, key, algo));
490  }
491  }
492  }
493 }
494 
495 
502  const std::string& what) const
503 {
504  if (bad.empty()) return;
505  std::vector<std::string> lines;
506  for (const BadListItem& id : bad) {
507  lines.push_back (id.fullKey() + " [" + id.m_algo + "]");
508  }
509  std::sort (lines.begin(), lines.end());
510  warning() << "Called " << what << " on these objects in a MT store" << endmsg;
511  for (const std::string& s : lines) {
512  warning() << s << endmsg;
513  }
514 }
515 
516 
518 {
519  std::cout << sg->dump() << "\n";
520 }
521 
522 void SG_dump (StoreGateSvc* sg, const char* fname)
523 {
524  std::ofstream f (fname);
525  f << sg->dump() << "\n";
526  f.close();
527 }
528 
StoreGateSvc::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: StoreGateSvc.cxx:305
bad
@ bad
Definition: SUSYToolsTester.cxx:95
SG::HiveEventSlot
Definition: SGHiveEventSlot.h:19
StoreGateSvc::typeCount
int typeCount() const
Return the number of instances of an object of type T int i = p_store->typeCount<T>(); Note that th...
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:50
StoreGateSvc::setSlot
static void setSlot(SG::HiveEventSlot *pSlot)
set the hive event slot pointer: used by the event loop mgrs
Definition: StoreGateSvc.cxx:44
StoreGateSvc::clearProxyPayload
void clearProxyPayload(SG::DataProxy *)
use to reset a proxy (clearing the data object it contains) Unlike DataProxy::reset this method corre...
Definition: StoreGateSvc.cxx:409
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:407
SG
Forward declaration.
Definition: CaloCellPacker_400_500.h:32
SG_dump
void SG_dump(StoreGateSvc *sg)
These are intended to be easy to call from the debugger.
Definition: StoreGateSvc.cxx:517
StoreGateSvc::stop
virtual StatusCode stop() override
Service start.
Definition: StoreGateSvc.cxx:159
StoreGateSvc::handle
virtual void handle(const Incident &) override final
Definition: StoreGateSvc.cxx:173
initialize
void initialize()
Definition: run_EoverP.cxx:894
DataStore.h
StoreGateSvc::makeCurrent
void makeCurrent()
The current store is becoming the active store.
Definition: StoreGateSvc.cxx:442
StoreGateSvc::~StoreGateSvc
virtual ~StoreGateSvc() override
Standard Destructor.
Definition: StoreGateSvc.cxx:35
StoreGateSvc::printBadList
void printBadList(const BadItemList &bad, const std::string &what) const
Print out a list of bad calls during finalization.
Definition: StoreGateSvc.cxx:501
StoreGateSvc::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: StoreGateSvc.cxx:321
StoreGateSvc::commitNewDataObjects
virtual void commitNewDataObjects() override final
Reset handles added since the last call to commit.
Definition: StoreGateSvc.cxx:76
python.RatesEmulationExample.lock
lock
Definition: RatesEmulationExample.py:148
StoreGateSvc::keys
void keys(std::vector< std::string > &vkeys, bool includeAlias=false, bool onlyValid=true) const
provide list of all StoreGate keys associated with an object.
python.DualUseConfig.createService
def createService(typeName, serviceName, sequence=None)
Definition: DualUseConfig.py:127
StoreGateSvc::removeProxy
StatusCode removeProxy(SG::DataProxy *proxy, const void *pTrans, bool forceRemove=false)
remove proxy from store, unless it is reset only.
Definition: StoreGateSvc.cxx:447
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
StoreGateSvc::remap_impl
void remap_impl(sgkey_t source, sgkey_t target, off_t index_offset)
Declare a remapping.
Definition: StoreGateSvc.cxx:383
run_Egamma1_LArStrip_Fex.dump
dump
Definition: run_Egamma1_LArStrip_Fex.py:87
StoreGateSvc::proxyRange
StatusCode proxyRange(const CLID &id, SG::ConstProxyIterator &beg, SG::ConstProxyIterator &end) const
return a range to all proxies of a given CLID
Definition: StoreGateSvc.cxx:396
DiTauMassTools::ignore
void ignore(T &&)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:58
StoreGateSvc::emptyTrash
void emptyTrash()
throw away bad objects
Definition: StoreGateSvc.cxx:435
StoreGateSvc::finalize
virtual StatusCode finalize() override
Definition: StoreGateSvc.cxx:180
ArenaHeader.h
Proxy for a group of Arenas. See Arena.h for an overview of the arena-based memory allocators.
StoreGateSvc::releaseObject
void releaseObject(const CLID &id, const std::string &key)
release object held by proxy, if any.
Definition: StoreGateSvc.cxx:404
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
StoreGateSvc::initialize
virtual StatusCode initialize() override
Service initialization.
Definition: StoreGateSvc.cxx:101
StoreGateSvc::dump
std::string dump() const
dump objects in store.
Definition: StoreGateSvc.cxx:349
CaloCondBlobAlgs_fillNoiseFromASCII.lines
lines
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:103
StoreGateSvc::BadItemList
std::unordered_set< BadListItem, DataObjID_Hasher > BadItemList
Definition: StoreGateSvc.h:928
StoreGateSvc::sgkey_t
IStringPool::sgkey_t sgkey_t
Definition: StoreGateSvc.h:641
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SGImplSvc.h
StoreGateSvc::currentStoreGate
static StoreGateSvc * currentStoreGate()
get current StoreGate
Definition: StoreGateSvc.cxx:51
StoreGateSvc::setDefaultStore
void setDefaultStore(SGImplSvc *pStore)
set pointer to default event store: used by ActiveStoreSvc
Definition: StoreGateSvc.cxx:39
StoreGateSvc::keyToString
virtual const std::string * keyToString(sgkey_t key) const override final
Find the string corresponding to a given key.
StoreGateSvc::loadEventProxies
StatusCode loadEventProxies()
load proxies at begin event
Definition: StoreGateSvc.cxx:415
SGImplSvc
The Athena Transient Store API.
Definition: SGImplSvc.h:109
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
StoreID
defines an enum used by address providers to decide what kind of StoreGateSvc they are providing addr...
Definition: StoreID.h:18
hist_file_dump.f
f
Definition: hist_file_dump.py:140
StoreGateSvc::clearStore
virtual StatusCode clearStore(bool forceRemove=false) override final
clear DataStore contents: called by the event loop mgrs
Definition: StoreGateSvc.cxx:423
Handler::svc
AthROOTErrorHandlerSvc * svc
Definition: AthROOTErrorHandlerSvc.cxx:10
StoreGateSvc::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: StoreGateSvc.cxx:377
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
SG::HiveEventSlot::pEvtStore
SGImplSvc * pEvtStore
Definition: SGHiveEventSlot.h:23
StoreGateSvc::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: StoreGateSvc.cxx:313
StoreGateSvc::stringToKey
virtual sgkey_t stringToKey(const std::string &str, CLID clid) override final
Find the key for a string/CLID pair.
Definition: StoreGateSvc.cxx:362
StoreGateSvc::clids
std::vector< CLID > clids() const
Return all CLIDs in the store.
Definition: StoreGateSvc.cxx:278
StoreGateSvc::createObj
virtual StatusCode createObj(IConverter *cvt, IOpaqueAddress *addr, DataObject *&refpObject) override
Call converter to create an object, with locking.
Definition: StoreGateSvc.cxx:464
StoreGateSvc::rememberBad
void rememberBad(BadItemList &bad, CLID clid, const std::string &key) const
Remember that retrieve or record was called for a MT store.
Definition: StoreGateSvc.cxx:478
python.ExitCodes.what
def what(code)
Definition: ExitCodes.py:73
WriteBchToCool.beg
beg
Definition: WriteBchToCool.py:69
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
StoreGateSvc::proxy
virtual SG::DataProxy * proxy(const void *const pTransient) const override final
get proxy for a given data object address in memory
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
StoreGateSvc::lock_t
std::lock_guard< mutex_t > lock_t
Definition: StoreGateSvc.h:938
errorcheck.h
Helpers for checking error return status codes and reporting errors.
StoreGateSvc::setConst
StatusCode setConst(const void *pointer)
prevent downstream clients from modifying the pointed-at dobj
Definition: StoreGateSvc.cxx:94
RegSelToolConfig.alg
alg
Definition: RegSelToolConfig.py:332
SG::sgkey_t
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition: CxxUtils/CxxUtils/sgkey_t.h:32
StoreClearedIncident.h
Incident sent after a store is cleared.
StoreGateSvc::recordAddress
StatusCode recordAddress(const std::string &skey, IOpaqueAddress *pAddress, bool clearAddressFlag=true)
Create a proxy object using an IOpaqueAddress and a transient key.
StoreGateSvc::accessData
DataObject * accessData(const CLID &id) const
find proxy and access its data. Returns 0 to flag failure
Definition: StoreGateSvc.cxx:294
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:66
StoreGateSvc::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: StoreGateSvc.cxx:260
StoreGateSvc::proxies
virtual std::vector< const SG::DataProxy * > proxies() const override final
return the list of all current proxies in store
Definition: StoreGateSvc.cxx:271
StoreGateSvc::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: StoreGateSvc.cxx:390
hydjet.StoreGateSvc
StoreGateSvc
Definition: hydjet.minbias.pbpb5520.r12345.job.py:40
SGImplSvc::makeCurrent
void makeCurrent()
The current store is becoming the active store.
Definition: SGImplSvc.cxx:1779
StoreID::type
type
Definition: StoreID.h:24
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
copySelective.target
string target
Definition: copySelective.py:36
StoreGateSvc::setStoreID
void setStoreID(StoreID::type id)
set store ID. request forwarded to DataStore:
Definition: StoreGateSvc.cxx:332
python.TriggerHandler.verbose
verbose
Definition: TriggerHandler.py:296
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
copySelective.source
string source
Definition: copySelective.py:31
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
StoreGateSvc::transientProxy
SG::DataProxy * transientProxy(const CLID &id, const std::string &key) const
get proxy with given id and key.
Definition: StoreGateSvc.cxx:287
StoreID::EVENT_STORE
@ EVENT_STORE
Definition: StoreID.h:26
SG::DataObjectSharedPtr
Smart pointer to manage DataObject reference counts.
Definition: DataObjectSharedPtr.h:45
StoreGateSvc::addToStore
virtual StatusCode addToStore(CLID id, SG::DataProxy *proxy) override final
Raw addition of a proxy to the store.
Definition: StoreGateSvc.cxx:233
get_generator_info.error
error
Definition: get_generator_info.py:40
python.PyAthena.obj
obj
Definition: PyAthena.py:132
SG::DataProxy
Definition: DataProxy.h:45
StoreGateSvc.h
StoreGateSvc::BadListItem
Definition: StoreGateSvc.h:921
StoreGateSvc::StoreGateSvc
StoreGateSvc(const std::string &name, ISvcLocator *svc)
Standard Constructor.
Definition: StoreGateSvc.cxx:28
StoreGateSvc::currentSlot
static SG::HiveEventSlot * currentSlot()
Definition: StoreGateSvc.cxx:68
SG::ConstProxyIterator
ProxyMap::const_iterator ConstProxyIterator
Definition: ProxyMap.h:28
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
StoreClearedIncident
Incident sent after a store is cleared.
Definition: StoreClearedIncident.h:30