Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
StoreGateSvc.h
Go to the documentation of this file.
1 /* -*- C++ -*- */
2 
3 /*
4  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
5 */
6 
7 #ifndef STOREGATE_STOREGATESVC_H
8 #define STOREGATE_STOREGATESVC_H
9 
10 //FIXME the CLASS_DEF header is not needed here but was added to work around
11 //bad include statements in client code: when using CLASS_DEF put the
12 //include below in your header file!
13 #include "AthenaKernel/CLASS_DEF.h"
14 
15 //HIVE wrapper implementation
16 //base classes
17 #include "GaudiKernel/Service.h"
18 #include "AthenaKernel/IProxyDict.h"
19 
20 #include "AthenaKernel/IHiveStore.h"
21 #include "AthenaKernel/IHiveStoreMgr.h"
22 #include "StoreGate/tools/SGImplSvc.h"
23 #include "StoreGate/SGHiveEventSlot.h"
24 
25 #include <GaudiKernel/ClassID.h> // for CLID
26 #include <GaudiKernel/IInterface.h> // for InterfaceID
27 #include <GaudiKernel/IMessageSvc.h> // for Level
28 #include "Gaudi/Property.h"
29 #include "GaudiKernel/ServiceHandle.h"
30 #include "GaudiKernel/StatusCode.h"
31 #include "GaudiKernel/DataObjID.h"
32 #include "GaudiKernel/IAlgContextSvc.h"
33 
34 #include <cstddef> // for size_t
35 #include <list>
36 #include <memory>
37 #include <mutex>
38 #include <string>
39 #include <sys/types.h> // for off_t
40 #include <vector>
41 #include <type_traits>
42 
43 #include "AthenaKernel/StoreID.h"
44 #include "AthenaKernel/IOVSvcDefs.h"
45 #include "AthenaKernel/DefaultKey.h"
46 #include "AthAllocators/Arena.h"
47 
48 #include <SGTools/StringPool.h>
49 #include "SGTools/ProxyMap.h" /* for SG::ConstProxyIterator */
50 
51 // includes used in StoreGateSvc.icc
52 #include "GaudiKernel/IClassIDSvc.h"
53 #include "AthenaKernel/IResetable.h"
54 #include "AthenaKernel/IIOVSvc.h"
55 #include "StoreGate/SGIterator.h"
56 #include "StoreGate/DataHandle.h"
57 #include "StoreGate/SGWPtr.h"
58 #include "StoreGate/SGObjectWithVersion.h"
59 #include "CxxUtils/checker_macros.h"
60 
61 #include "GaudiKernel/IIncidentListener.h"
62 
63 
64 //forward declarations
65 namespace SG {
66  class DataProxy;
67  class TransientAddress;
68  struct RemapImpl;
69  class TestHiveStoreSvc;
70  class HiveMgrSvc;
71 }
72 namespace xAODMaker {
73  class AuxStoreWrapper;
74 }
75 
76 class DataObject;
77 class IConversionSvc;
78 class IIncidentSvc;
79 class IProxyProviderSvc;
80 class IHistorySvc;
81 
82 // python forward
83 struct _object; typedef _object PyObject;
84 class StoreGateSvc;
85 namespace AthenaInternal {
86  PyObject* recordObjectToStore(StoreGateSvc*,PyObject*,PyObject*,bool,bool,bool);
87  void py_sg_clearProxyPayload(StoreGateSvc* self, SG::DataProxy*);
88 }
89 namespace SG {
90  class NoAuxStore;
91 }
92 
93 //friends...
94 class AthenaOutputStream;
95 class IOVDbSvc;
96 class IOVSvcTool;
97 class PileUpMergeSvc;
98 namespace SG {
99  class VarHandleBase;
100 }
101 
118 class StoreGateSvc :
119  public Service,
120  public IProxyDict,
121  virtual public IHiveStore,
122  public IHiveStoreMgr,
123  public IIncidentListener
124 {
125 
126 public:
127 #ifndef BOOST_NO_CXX11_TEMPLATE_ALIASES
128 #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
129 
132 
151  template <typename T, typename TKEY, typename... ARGS>
152  SG::WPtr<T> create(const TKEY& key, ARGS... constructorArgs);
154 #endif /* needs C++11 variadic templates to call arbitrary constructors */
155 #endif /* needs "templated typedef" to define SG::WPtr (for now) */
156 
159 
160 
162  template <typename T, typename TKEY>
163  StatusCode record(T* p2BRegistered, const TKEY& key);
164 
166  template <typename T, typename TKEY>
167  StatusCode record(const T* p2BRegistered, const TKEY& key);
168 
169 
172  template <typename T, typename TKEY>
173  StatusCode record(T* p2BRegistered, const TKEY& key,
174  bool allowMods, bool resetOnly=true, bool noHist=false);
175 
177  template <typename T, typename TKEY>
178  StatusCode record(std::unique_ptr<T> pUnique, const TKEY& key);
179 
181  template <typename T, typename TKEY>
182  StatusCode record(std::unique_ptr<const T> pUnique, const TKEY& key);
183 
186  template <typename T, typename TKEY>
187  StatusCode record(std::unique_ptr<T> pUnique, const TKEY& key,
188  bool allowMods, bool resetOnly=true, bool noHist=false);
189 
191 
194 
195 
197  template <typename T>
198  StatusCode retrieve(const T*& ptr) const;
199 
201  template <typename T>
202  StatusCode retrieve(T*& ptr) const;
203 
206  template <typename T>
207  T* retrieve () const;
208 
211  template <typename T>
212  T* tryRetrieve () const;
213  template <typename T>
214  const T* tryConstRetrieve() const;
215 
217  template <typename T, typename TKEY>
218  StatusCode retrieve(const T*& ptr, const TKEY& key) const;
219 
222  template <typename T>
223  StatusCode retrieve(const T*& ptr, const std::string& key) const;
224 
225 
227  template <typename T, typename TKEY>
228  StatusCode retrieve(T*& ptr, const TKEY& key) const;
229 
232  template <typename T>
233  StatusCode retrieve(T*& ptr, const std::string& key) const;
234 
235 
238  template <typename T, class TKEY>
239  T* retrieve (const TKEY& key) const;
240 
243  template <typename T, class TKEY>
244  T* tryRetrieve (const TKEY& key) const;
245  template <typename T, class TKEY>
246  const T* tryConstRetrieve(const TKEY& key) const;
247 
248 
249 
251  template <typename T>
252  StatusCode retrieve(SG::ConstIterator<T>& begin,
253  SG::ConstIterator<T>& end) const;
254 
258  template <typename T, typename TKEY>
260  bool contains(const TKEY& key) const;
261 
275  template <typename T, typename TKEY>
276  StatusCode bind ATLAS_NOT_THREAD_SAFE (const DataHandle<T>& handle, const TKEY& key);
277 
279 
282 
283 
285  template <typename T, typename TKEY>
286  StatusCode overwrite(T* p2BRegistered, const TKEY& key);
287 
289  template <typename T, typename TKEY>
290  StatusCode overwrite(T* p2BRegistered, const TKEY& key,
291  bool allowMods, bool noHist=false);
292 
293 
295  template <typename T, typename TKEY>
296  StatusCode overwrite(std::unique_ptr<T> pUnique, const TKEY& key,
297  bool allowMods, bool noHist=false);
298 
300  template <typename T, typename TKEY>
301  StatusCode overwrite(std::unique_ptr<T> pUnique, const TKEY& key);
302 
304  StatusCode recordAddress(const std::string& skey,
305  IOpaqueAddress* pAddress, bool clearAddressFlag=true);
307  StatusCode recordAddress(IOpaqueAddress* pAddress, bool clearAddressFlag=true);
308 
310  template <typename T, typename TLINK>
311  StatusCode symLink (const T* p2BRegistered, TLINK* p2BLinked );
312 
314  template <typename T, typename TLINK>
315  StatusCode symLink (const T* p2BRegistered, const TLINK* p2BLinked );
316 
318  template <typename TKEY>
319  StatusCode symLink (const CLID id, const TKEY& key, const CLID linkid);
320 
322  template <typename T, typename TKEY, typename AKEY>
323  StatusCode setAlias(const T* p2BAliased, const TKEY& key, const AKEY& aliasKey);
324 
326  template <typename T, typename AKEY>
327  StatusCode setAlias(const T* p2BAliased, const AKEY& aliasKey);
328 
330  StatusCode setAlias(SG::DataProxy* proxy, const std::string& aliasKey);
331 
333  StatusCode setConst(const void* pointer);
334 
336  template <typename T>
337  StatusCode remove(const T* pObject);
338 
340  template <typename T>
341  StatusCode removeDataAndProxy(const T* pObject);
342 
348  bool transientSwap( const CLID& id,
349  const std::string& keyA, const std::string& keyB );
350 
352 
355 
356 
365  template <typename T, class TKEY>
366  StatusCode retrieveHighestVersion(SG::ObjectWithVersion<T>& dobjWithVersion,
367  const TKEY& requestedKey) const;
368 
374  //FIXME using a vector exposes ObjectWithVersion definition and hence
375  //FIXME VersionedKey.h. Should try an iface like
376  //FIXME retrieveAllVersions(const TKEY& requestedKey,
377  //FIXME ObjectWithVersion<T>& begin,
378  //FIXME ObjectWithVersion<T>& end)
379  template <typename T, class TKEY>
380  StatusCode
381  retrieveAllVersions(std::list< SG::ObjectWithVersion<T> >& allVersions,
382  const TKEY& requestedKey) const;
383 
384 
385 
397  template <typename T>
398  std::unique_ptr<T> retrieveUniquePrivateCopy (const std::string& key);
399 
403  template<typename TKEY>
404  CLID clid( const TKEY& key ) const;
405 
409  template<typename TKEY>
410  std::vector<CLID> clids( const TKEY& key ) const;
411 
416  template <typename T>
417  int typeCount() const;
418 
420  int typeCount(const CLID& id) const;
421 
425  template <typename TKEY>
426  bool contains(const CLID& id, const TKEY& key) const;
427 
428 
432  template <typename T, typename TKEY>
434  bool transientContains(const TKEY& key) const;
435 
438  template <typename TKEY>
439  bool transientContains(const CLID& id, const TKEY& key) const;
440 
443  std::string dump() const;
444 
446  void setStoreID(StoreID::type id);
448  StoreID::type storeID() const;
449 
450 
457  template <typename T>
458  void
459  keys(std::vector<std::string>& vkeys,
460  bool includeAlias = false, bool onlyValid = true) const;
461 
469  void
470  keys(const CLID& id, std::vector<std::string>& vkeys,
471  bool includeAlias = false, bool onlyValid = true) const;
472 
474 
475 
477  // FIXME pointer to unsafe impl exposed
478  virtual ::IProxyDict* hiveProxyDict() override final {
479  return StoreGateSvc::currentStore();
480  }
481 
483  static StoreGateSvc* currentStoreGate();
484 
485 
488 
489  virtual StatusCode clearStore(bool forceRemove=false) override final;
492 
495  virtual void commitNewDataObjects() override final;
497 
499  static void setSlot(SG::HiveEventSlot* pSlot);
500 
501 
503  void setDefaultStore(SGImplSvc* pStore);
504 
505 
508 
509 
510  template <typename H, typename TKEY>
511  StatusCode regHandle ATLAS_NOT_THREAD_SAFE ( const DataHandle<H>& handle, const TKEY& key );
512 
514  template <typename H, typename TKEY>
515  StatusCode regHandle( DataHandle<H>& handle, const TKEY& key);
516 
518  template <typename T, typename H, typename TKEY>
519  StatusCode regFcn ATLAS_NOT_THREAD_SAFE (StatusCode (T::*updFcn)(IOVSVC_CALLBACK_ARGS),
520  const T* obj, const DataHandle<H>& handle,
521  const TKEY& key, bool trigger=false);
522 
524  template <typename T, typename H, typename TKEY>
525  StatusCode regFcn ATLAS_NOT_THREAD_SAFE (StatusCode (T::*updFcn)(IOVSVC_CALLBACK_ARGS),
526  const T* obj, DataHandle<H>& handle,
527  const TKEY& key, bool trigger=false);
528 
530  template <typename T1, typename T2>
531  StatusCode regFcn ATLAS_NOT_THREAD_SAFE (StatusCode (T1::*fcn1)(IOVSVC_CALLBACK_ARGS),
532  const T1* obj1,
533  StatusCode (T2::*fcn2)(IOVSVC_CALLBACK_ARGS),
534  const T2* obj2, bool trigger=false);
535 
537  template <typename T2>
538  StatusCode regFcn ATLAS_NOT_THREAD_SAFE (const std::string& toolName,
539  StatusCode (T2::*fcn2)(IOVSVC_CALLBACK_ARGS),
540  const T2* obj2, bool trigger=false);
541 
543 
546  virtual SG::DataProxy* proxy(const void* const pTransient) const override final;
547 
549  virtual SG::DataProxy* proxy(const CLID& id) const final;
550 
552  virtual SG::DataProxy* proxy(const CLID& id, const std::string& key) const override final;
555  SG::DataProxy* proxy(const CLID& id, const char* key) const;
556 
558  virtual StatusCode addToStore (CLID id, SG::DataProxy* proxy) override final;
559 
580  virtual
581  SG::DataProxy* recordObject (SG::DataObjectSharedPtr<DataObject> obj,
582  const std::string& key,
583  bool allowMods,
584  bool returnExisting) override final;
585 
586 
590  virtual SG::DataProxy* proxy_exact (SG::sgkey_t sgkey) const override final;
591 
592 
594 
596 
597  virtual SG::DataProxy* proxy(const CLID& id, bool checkValid) const final;
602  virtual SG::DataProxy* proxy(const CLID& id, const std::string& key, bool checkValid) const final;
606  virtual SG::DataProxy* proxy(const CLID& id, const char* key, bool checkValid) const final
607  { return this->proxy(id, std::string(key), checkValid); }
608 
610  virtual std::vector<const SG::DataProxy*> proxies() const override final;
611 
613  std::vector<CLID> clids() const;
614 
617  SG::DataProxy* transientProxy(const CLID& id, const std::string& key) const;
618 
620  DataObject* accessData(const CLID& id) const;
622  DataObject* accessData(const CLID& id, const std::string& key) const;
623 
625  void setProxyProviderSvc(IProxyProviderSvc* pPPSvc);
627  IProxyProviderSvc* proxyProviderSvc();
629 
630 
638  virtual SG::SourceID sourceID (const std::string& key = "EventSelector") const override;
639 
640 
643 
644 
645  typedef IStringPool::sgkey_t sgkey_t;
646 
655  virtual
656  sgkey_t stringToKey (const std::string& str, CLID clid) override final;
657 
665  virtual
666  const std::string* keyToString (sgkey_t key) const override final;
667 
676  virtual
677  const std::string* keyToString (sgkey_t key, CLID& clid) const override final;
678 
691  virtual
692  void registerKey (sgkey_t key,
693  const std::string& str,
694  CLID clidid) override final;
695 
697 
700 
701 
702 
725  template <class TKEY>
726  void remap (CLID clid,
727  const TKEY& source,
728  const TKEY& target,
729  off_t index_offset);
730 
731 
739  void remap_impl (sgkey_t source,
740  sgkey_t target,
741  off_t index_offset);
742 
743 
752  virtual bool tryELRemap (sgkey_t sgkey_in, size_t index_in,
753  sgkey_t& sgkey_out, size_t& index_out) override final;
754 
756 
759 
760  StoreGateSvc(const std::string& name, ISvcLocator* svc);
761  virtual ~StoreGateSvc() override;
763 
766 
767  virtual StatusCode initialize() override;
768  virtual StatusCode stop() override;
769  virtual StatusCode finalize() override;
770  virtual StatusCode queryInterface( const InterfaceID& riid, void** ppvInterface ) override;
772  static const InterfaceID& interfaceID();
774 
775 
778 
779  virtual void handle(const Incident&) override final;
781  StatusCode loadEventProxies();
783 
784 
795  virtual
796  StatusCode createObj (IConverter* cvt,
797  IOpaqueAddress* addr,
798  DataObject*& refpObject) override;
799 
803  void makeCurrent();
804 
805 
806 private:
807 
808  SGImplSvc* m_defaultStore;
809  ServiceHandle<IProxyProviderSvc> m_pPPSHandle;
810  ServiceHandle<IIncidentSvc> m_incSvc;
811 
812 
813  friend class SG::TestHiveStoreSvc;
814  static SG::HiveEventSlot* currentSlot();
815 
816  friend class SG::HiveMgrSvc;
818  SGImplSvc* currentStore() const;
819 
820 
822  friend class AthenaOutputStream;
824  StatusCode proxyRange(const CLID& id,
825  SG::ConstProxyIterator& beg,
826  SG::ConstProxyIterator& end) const;
827 
829  friend class xAODMaker::AuxStoreWrapper;
832  void releaseObject(const CLID& id, const std::string& key);
833 
834 
836  friend class PileUpMergeSvc;
838  friend class IOVDbSvc;
839  friend class IOVSvcTool;
840  friend
841  void
842  AthenaInternal::py_sg_clearProxyPayload(StoreGateSvc*, SG::DataProxy*);
843 
846  void clearProxyPayload(SG::DataProxy*);
847 
849  friend class SG::VarHandleBase;
850  friend
851  PyObject*
852  AthenaInternal::recordObjectToStore(StoreGateSvc*,PyObject*,PyObject*,bool,bool,bool);
855  StatusCode typeless_record( DataObject* obj, const std::string& key,
856  const void* const raw_ptr,
857  bool allowMods, bool resetOnly=true,
858  bool noHist=false );
860  StatusCode typeless_overwrite( const CLID& id,
861  DataObject* obj, const std::string& key,
862  const void* const raw_ptr,
863  bool allowMods,
864  bool noHist=false,
865  const std::type_info* tinfo=0);
866 
867  // Helper for record.
868  template <typename T, typename TKEY>
869  StatusCode record1(DataObject* obj, T* pObject, const TKEY& key,
870  bool allowMods, bool resetOnly=true, bool noHist=false);
871 
872  // Helper for overwrite.
873  template <typename T, typename TKEY>
874  StatusCode overwrite1(DataObject* obj, T* pObject, const TKEY& key,
875  bool allowMods, bool noHist=false);
876 
877  bool isSymLinked(const CLID& linkID, SG::DataProxy* dp);
878 
879  StatusCode addSymLink(const CLID& linkid, SG::DataProxy* dp);
880 
881  StatusCode addAlias(const std::string& aliasKey, SG::DataProxy* dp);
882 
884  std::string createKey(const CLID& dataID);
885 
887  SG::DataProxy* setupProxy(const CLID& dataID,
888  const std::string& gK,
889  DataObject* pDObj,
890  bool allowMods,
891  bool resetOnly);
892 
894  void recycle(DataObject* pBadDObj);
896  void emptyTrash();
897 
903  StatusCode removeProxy(SG::DataProxy* proxy, const void* pTrans,
904  bool forceRemove=false);
906  StatusCode t2pRegister(const void* const pTrans, SG::DataProxy* const pPers);
908  void t2pRemove(const void* const pTrans);
909 
911  void msg_update_handler(Gaudi::Details::PropertyBase& outputLevel);
912 
914  void addAutoSymLinks (const std::string& key, CLID clid, SG::DataProxy* dp,
915  const std::type_info* tinfo,
916  bool warn_nobib = true);
917 
918  bool m_DumpStore;
919  bool m_ActivateHistory;
920  bool m_DumpArena;
921 
923  StoreID::type m_storeID;
924 
926  ServiceHandle<IAlgContextSvc> m_algContextSvc;
927 
928  struct BadListItem
929  : public DataObjID
930  {
931  public:
932  BadListItem (CLID clid, const std::string& key, const std::string& algo)
933  : DataObjID (clid, key), m_algo (algo)
934  {}
935  std::string m_algo;
936  };
937  typedef std::unordered_set<BadListItem, DataObjID_Hasher> BadItemList;
938 
941  // Thread-safe, since they're protected by m_badMutex.
942  mutable BadItemList m_badRetrieves ATLAS_THREAD_SAFE;
943  mutable BadItemList m_badRecords ATLAS_THREAD_SAFE;
944 
946  typedef std::mutex mutex_t;
947  typedef std::lock_guard<mutex_t> lock_t;
948  mutable mutex_t m_badMutex;
949 
950 
956  void rememberBadRetrieve (CLID clid, const std::string& key) const;
957 
958 
964  void rememberBadRecord (CLID clid, const std::string& key) const;
965 
966 
973  void rememberBad (BadItemList& bad,
974  CLID clid,
975  const std::string& key) const;
976 
977 
983  void printBadList (const BadItemList& bad,
984  const std::string& what) const;
985 
986 
992  template <class DOBJ>
993  bool associateAux (DOBJ*,
994  const std::string& key,
995  bool ignoreMissing=true) const;
996  template <class DOBJ>
997  bool associateAux (const DOBJ*,
998  const std::string& key,
999  bool ignoreMissing=true) const;
1000 
1001  template <class DOBJ, class AUXSTORE>
1002  bool associateAux_impl(DOBJ* ptr,
1003  const std::string& key,
1004  const AUXSTORE*) const;
1005  template <class DOBJ>
1006  bool associateAux_impl(DOBJ* /*ptr*/,
1007  const std::string& /*key*/,
1008  const SG::NoAuxStore*) const;
1009 
1010 
1011 private:
1012  StoreGateSvc (const StoreGateSvc&);
1013  StoreGateSvc& operator= (const StoreGateSvc&);
1014 };
1015 
1016 
1018 void SG_dump (StoreGateSvc* sg);
1019 void SG_dump (StoreGateSvc* sg, const char* fname);
1020 
1021 
1022 #include "StoreGate/StoreGateSvc.icc"
1023 
1024 
1025 //- PyGate: StoreGate access from python -------------------------------------
1026 template< class T >
1027 struct PyGate {
1028  // default object retrieval
1029  static const T* retrieve( StoreGateSvc* psg ) {
1030  const T* obj = 0;
1031  if ( StatusCode::SUCCESS == psg->retrieve( obj ) )
1032  return obj;
1033  return 0;
1034  }
1035 
1036  // object retrieval with string key
1037  static const T* retrieve( StoreGateSvc* psg, const std::string& key ) {
1038  const T* obj = 0;
1039  if ( StatusCode::SUCCESS == psg->retrieve( obj, key ) )
1040  return obj;
1041  return 0;
1042  }
1043 };
1044 
1045 #endif // STOREGATE_STOREGATESVC_H
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:332
IOVDbSvc
Athena service for Interval Of Validity database. The IOVDbSvc may be in one of three time states whi...
Definition: IOVDbSvc.h:83
StoreGateSvc::record
StatusCode record(T *p2BRegistered, const TKEY &key)
Record an object with a key.
bad
@ bad
Definition: SUSYToolsTester.cxx:100
common.sgkey
def sgkey(tool)
Definition: common.py:1028
IStringPool
Abstract interface for looking up strings/CLIDs in a pool.
Definition: IStringPool.h:28
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...
TileDCSDataPlotter.dp
dp
Definition: TileDCSDataPlotter.py:840
StoreGateSvc::contains
bool contains(const TKEY &key) const
Look up a keyed object in TDS (compare also tryRetrieve) returns false if object not available in TDS...
StoreGateSvc::createKey
std::string createKey(const CLID &dataID)
creates a key internally if none specified by client
StoreGateSvc::addSymLink
StatusCode addSymLink(const CLID &linkid, SG::DataProxy *dp)
StoreGateSvc::tryRetrieve
T * tryRetrieve(const TKEY &key) const
Variant of the above which doesn't print a warning message.
StoreGateSvc::setSlot
static void setSlot(SG::HiveEventSlot *pSlot)
set the hive event slot pointer: used by the event loop mgrs
Definition: StoreGateSvc.cxx:62
StoreGateSvc::retrieve
T * retrieve() const
Variant of the above which doesn't return a status code.
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:436
StoreGateSvc::associateAux_impl
bool associateAux_impl(DOBJ *, const std::string &, const SG::NoAuxStore *) const
IHiveStore.h
SG
Forward declaration.
Definition: CaloCellPacker_400_500.h:32
StoreGateSvc::retrieve
T * retrieve(const TKEY &key) const
Variant of the above which doesn't return a status code.
StoreGateSvc::interfaceID
static const InterfaceID & interfaceID()
Should rather be in IStoreGateSvc.h if we had one.
Definition: StoreGateSvc.cxx:467
StoreGateSvc::stop
virtual StatusCode stop() override
Service start.
Definition: StoreGateSvc.cxx:183
StoreGateSvc::keys
void keys(const CLID &id, std::vector< std::string > &vkeys, bool includeAlias=false, bool onlyValid=true) const
provide list of all StoreGate keys associated with an object.
StoreGateSvc::BadListItem::BadListItem
BadListItem(CLID clid, const std::string &key, const std::string &algo)
Definition: StoreGateSvc.h:932
StoreGateSvc::setProxyProviderSvc
void setProxyProviderSvc(IProxyProviderSvc *pPPSvc)
associate ProxyProviderSvc to this store
StoreGateSvc::setAlias
StatusCode setAlias(const T *p2BAliased, const TKEY &key, const AKEY &aliasKey)
make an alias to a DataObject (provide data type and old key)
EventInfoWrite.EventSelector
EventSelector
Definition: EventInfoWrite.py:49
StoreGateSvc::handle
virtual void handle(const Incident &) override final
Definition: StoreGateSvc.cxx:199
BeamSpot::mutex
std::mutex mutex
Definition: InDetBeamSpotVertex.cxx:18
StoreGateSvc::retrieve
StatusCode retrieve(T *&ptr, const TKEY &key) const
Retrieve an object with "key", into a T*.
StoreGateSvc::msg_update_handler
void msg_update_handler(Gaudi::Details::PropertyBase &outputLevel)
callback for output level property
StoreGateSvc::m_storeID
StoreID::type m_storeID
Cache store type in the facade class.
Definition: StoreGateSvc.h:923
SGObjectWithVersion.h
associate a data object with its VersionedKey
PyGate
Definition: StoreGateSvc.h:1027
StoreGateSvc::tryRetrieve
T * tryRetrieve() const
Variant of the above which doesn't print a warning message.
StoreGateSvc::overwrite
StatusCode overwrite(T *p2BRegistered, const TKEY &key)
Record an object with a key, overwriting any existing object with same key.
StoreGateSvc::StoreGateSvc
StoreGateSvc(const StoreGateSvc &)
StoreGateSvc::overwrite
StatusCode overwrite(std::unique_ptr< T > pUnique, const TKEY &key)
Record an object with a key, overwriting any existing object with same key, take ownership of the uni...
StoreGateSvc::makeCurrent
void makeCurrent()
The current store is becoming the active store.
Definition: StoreGateSvc.cxx:496
StoreGateSvc::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
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
taskman.template
dictionary template
Definition: taskman.py:317
StoreGateSvc::ATLAS_THREAD_SAFE
BadItemList m_badRetrieves ATLAS_THREAD_SAFE
Remember calls to retrieve and record for a MT store, so we can warn about them during finalize().
Definition: StoreGateSvc.h:942
ReadCellNoiseFromCoolCompare.obj2
obj2
Definition: ReadCellNoiseFromCoolCompare.py:303
StoreGateSvc::m_ActivateHistory
bool m_ActivateHistory
property: activate the history service
Definition: StoreGateSvc.h:919
StoreGateSvc::m_DumpStore
bool m_DumpStore
property Dump: triggers dump() at EndEvent
Definition: StoreGateSvc.h:918
StoreGateSvc::printBadList
void printBadList(const BadItemList &bad, const std::string &what) const
Print out a list of bad calls during finalization.
Definition: StoreGateSvc.cxx:555
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:348
StoreGateSvc::commitNewDataObjects
virtual void commitNewDataObjects() override final
Reset handles added since the last call to commit.
Definition: StoreGateSvc.cxx:94
StoreGateSvc::currentStore
SGImplSvc * currentStore() const
returns pointer to the current SGImplSvc
StoreGateSvc::clid
CLID clid(const TKEY &key) const
Retrieve the main CLID of the object recorded in StoreGate with the given "key" WARNING: slow!
StoreGateSvc::associateAux
bool associateAux(const DOBJ *, const std::string &key, bool ignoreMissing=true) const
StoreGateSvc::typeCount
int typeCount(const CLID &id) const
Return the number of instances of type T (input CLID)
PyGate::retrieve
static const T * retrieve(StoreGateSvc *psg)
Definition: StoreGateSvc.h:1029
StoreGateSvc::m_pPPSHandle
ServiceHandle< IProxyProviderSvc > m_pPPSHandle
property
Definition: StoreGateSvc.h:809
StoreGateSvc::clids
std::vector< CLID > clids(const TKEY &key) const
Retrieve all the CLID s (including symlinks) of the object recorded in StoreGate with the given "key"...
SGIterator.h
A standard conforming forward iterator over items in StoreGate.
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:560
StoreGateSvc.icc
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.
xAODMaker
Definition: StoreGateSvc.h:72
IStringPool::sgkey_t
SG::sgkey_t sgkey_t
Type of the keys.
Definition: IStringPool.h:34
IOVSVC_CALLBACK_ARGS
#define IOVSVC_CALLBACK_ARGS
short hand for IOVSvc call back argument list, to be used when no access to formal arguments is neede...
Definition: IOVSvcDefs.h:24
StoreGateSvc::rememberBadRetrieve
void rememberBadRetrieve(CLID clid, const std::string &key) const
Remember that retrieve() was called for a MT store.
DataHandle.h
SG::WPtr
T * WPtr
Definition: SGWPtr.h:17
IProxyDict
A proxy dictionary.
Definition: AthenaKernel/AthenaKernel/IProxyDict.h:47
HiveEventSlot
A structure created by HiveMgrSvc and used by SGHiveStoreSvc to forward the StoreGateSvc method to a ...
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:501
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
StoreGateSvc::record
StatusCode record(std::unique_ptr< T > pUnique, const TKEY &key)
Record an object with a key, take ownership of the unique_ptr obj.
StoreGateSvc::record
StatusCode record(const T *p2BRegistered, const TKEY &key)
Record a const object with a key.
ProxyMap.h
StoreGateSvc::storeID
StoreID::type storeID() const
get store ID. request forwarded to DataStore:
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
StoreGateSvc::remap_impl
void remap_impl(sgkey_t source, sgkey_t target, off_t index_offset)
Declare a remapping.
Definition: StoreGateSvc.cxx:410
PileUpMergeSvc
the preferred mechanism to access information from the different event stores in a pileup job.
Definition: PileUpMergeSvc.h:56
StoreGateSvc::transientContains
bool transientContains(const CLID &id, const TKEY &key) const
Look up a transient data object in TDS only by CLID.
StoreGateSvc::retrieve
StatusCode retrieve(const T *&ptr) const
Retrieve the default object into a const T*.
StoreGateSvc::retrieveAllVersions
StatusCode retrieveAllVersions(std::list< SG::ObjectWithVersion< T > > &allVersions, const TKEY &requestedKey) const
Retrieve all versions of a given T,KEY combination sets allVersions, a ref to a vector of ObjectWithV...
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:423
StoreGateSvc::mutex_t
std::mutex mutex_t
Protect access to m_bad* members.
Definition: StoreGateSvc.h:946
StoreGateSvc::m_defaultStore
SGImplSvc * m_defaultStore
Definition: StoreGateSvc.h:808
AthenaInternal
Definition: AthenaPythonDict.h:31
SG::NoAuxStore
Mark that there's no associated AuxStore class.
Definition: AuxStore_traits.h:53
StoreGateSvc::emptyTrash
void emptyTrash()
throw away bad objects
Definition: StoreGateSvc.cxx:462
StoreGateSvc::m_DumpArena
bool m_DumpArena
DumpArena Property flag : trigger m_arena->report() at clearStore.
Definition: StoreGateSvc.h:920
StoreGateSvc::setAlias
StatusCode setAlias(const T *p2BAliased, const AKEY &aliasKey)
make an alias to a DataObject (provide only valid pointer)
StoreGateSvc::finalize
virtual StatusCode finalize() override
Definition: StoreGateSvc.cxx:206
StoreGateSvc::retrieve
StatusCode retrieve(const T *&ptr, const TKEY &key) const
Retrieve an object with "key", into a const T*.
StoreGateSvc
The Athena Transient Store API.
Definition: StoreGateSvc.h:124
StoreGateSvc::queryInterface
virtual StatusCode queryInterface(const InterfaceID &riid, void **ppvInterface) override
Definition: StoreGateSvc.cxx:471
H
#define H(x, y, z)
Definition: MD5.cxx:114
StoreGateSvc::releaseObject
void releaseObject(const CLID &id, const std::string &key)
release object held by proxy, if any.
Definition: StoreGateSvc.cxx:431
StoreGateSvc::record1
StatusCode record1(DataObject *obj, T *pObject, const TKEY &key, bool allowMods, bool resetOnly=true, bool noHist=false)
StoreGateSvc::operator=
StoreGateSvc & operator=(const StoreGateSvc &)
StoreGateSvc::tryConstRetrieve
const T * tryConstRetrieve(const TKEY &key) const
StoreGateSvc::initialize
virtual StatusCode initialize() override
Service initialization.
Definition: StoreGateSvc.cxx:119
StoreGateSvc::dump
std::string dump() const
dump objects in store.
Definition: StoreGateSvc.cxx:376
StoreGateSvc::regHandle
StatusCode regHandle(DataHandle< H > &handle, const TKEY &key)
non-const method - will return an error
StoreGateSvc::BadItemList
std::unordered_set< BadListItem, DataObjID_Hasher > BadItemList
Definition: StoreGateSvc.h:937
StoreGateSvc::overwrite
StatusCode overwrite(std::unique_ptr< T > pUnique, const TKEY &key, bool allowMods, bool noHist=false)
Record an object with a key, overwriting any existing object with same key.
StoreGateSvc::m_incSvc
ServiceHandle< IIncidentSvc > m_incSvc
property
Definition: StoreGateSvc.h:810
StoreGateSvc::BadListItem::m_algo
std::string m_algo
Definition: StoreGateSvc.h:935
StoreGateSvc::record
StatusCode record(std::unique_ptr< T > pUnique, const TKEY &key, bool allowMods, bool resetOnly=true, bool noHist=false)
Record an object with a key, allow possibility of specifying const-access.
StoreGateSvc::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.
PyObject
_object PyObject
Definition: StoreGateSvc.h:83
IResetable.h
StoreGateSvc::overwrite1
StatusCode overwrite1(DataObject *obj, T *pObject, const TKEY &key, bool allowMods, bool noHist=false)
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
vector
Definition: MultiHisto.h:13
SGImplSvc.h
StoreGateSvc::retrieve
StatusCode retrieve(T *&ptr) const
Retrieve the default object into a T*.
StoreGateSvc::retrieve
StatusCode retrieve(SG::ConstIterator< T > &begin, SG::ConstIterator< T > &end) const
Retrieve all objects of type T: returns an SG::ConstIterator range.
StoreGateSvc::currentStoreGate
static StoreGateSvc * currentStoreGate()
get current StoreGate
Definition: StoreGateSvc.cxx:69
StoreGateSvc::setDefaultStore
void setDefaultStore(SGImplSvc *pStore)
set pointer to default event store: used by ActiveStoreSvc
Definition: StoreGateSvc.cxx:55
DataProxy
DataProxy provides the registry services for StoreGate.
Definition: DataProxy.h:32
StringPool.h
Maintain a mapping of strings to 64-bit ints.
HiveMgrSvc
A service that manages a multi-event collection of StoreGateSvc It implements the IHiveWhiteBoard int...
Definition: SGHiveMgrSvc.h:22
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:442
StoreGateSvc::setAlias
StatusCode setAlias(SG::DataProxy *proxy, const std::string &aliasKey)
make an alias to a DataObject (provide valid proxy)
SGImplSvc
The Athena Transient Store API.
Definition: SGImplSvc.h:111
StoreID
defines an enum used by address providers to decide what kind of StoreGateSvc they are providing addr...
Definition: StoreID.h:18
StoreGateSvc::rememberBadRecord
void rememberBadRecord(CLID clid, const std::string &key) const
Remember that retrieve() was called for a MT store.
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
StoreGateSvc::clearStore
virtual StatusCode clearStore(bool forceRemove=false) override final
clear DataStore contents: called by the event loop mgrs
Definition: StoreGateSvc.cxx:450
Handler::svc
AthROOTErrorHandlerSvc * svc
Definition: AthROOTErrorHandlerSvc.cxx:10
StoreGateSvc::proxy_exact
virtual SG::DataProxy * proxy_exact(SG::sgkey_t sgkey) const override final
Get proxy given a hashed key+clid.
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:404
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
StoreGateSvc::ATLAS_NOT_THREAD_SAFE
StatusCode bind ATLAS_NOT_THREAD_SAFE(const DataHandle< T > &handle, const TKEY &key)
A "once-per-job" retrieve that binds a data object to a DataHandle, typically a data member of an Alg...
StoreGateSvc::overwrite
StatusCode overwrite(T *p2BRegistered, const TKEY &key, bool allowMods, bool noHist=false)
Record an object with a key, overwriting any existing object with same key.
StoreGateSvc::transientContains
bool transientContains(const TKEY &key) const
Look up a transient data object in TDS only (no Proxy lookup) returns false if object not available i...
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:340
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:389
StoreGateSvc::clids
std::vector< CLID > clids() const
Return all CLIDs in the store.
Definition: StoreGateSvc.cxx:305
StoreID.h
IOVSvcTool
Definition: IOVSvcTool.h:70
IProxyDict.h
StoreGateSvc::createObj
virtual StatusCode createObj(IConverter *cvt, IOpaqueAddress *addr, DataObject *&refpObject) override
Call converter to create an object, with locking.
Definition: StoreGateSvc.cxx:518
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:532
python.ExitCodes.what
def what(code)
Definition: ExitCodes.py:73
WriteBchToCool.beg
beg
Definition: WriteBchToCool.py:69
StoreGateSvc::proxy
virtual SG::DataProxy * proxy(const void *const pTransient) const override final
get proxy for a given data object address in memory
private
#define private
Definition: DetDescrConditionsDict_dict_fixes.cxx:13
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
IProxyProviderSvc
Definition: IProxyProviderSvc.h:34
StoreGateSvc::lock_t
std::lock_guard< mutex_t > lock_t
Definition: StoreGateSvc.h:947
columnar::final
CM final
Definition: ColumnAccessor.h:106
StoreGateSvc::symLink
StatusCode symLink(const T *p2BRegistered, TLINK *p2BLinked)
make a soft link to the object T* already registered (non-const)
StoreGateSvc::t2pRemove
void t2pRemove(const void *const pTrans)
forwarded to DataStore
StoreGateSvc::setConst
StatusCode setConst(const void *pointer)
prevent downstream clients from modifying the pointed-at dobj
Definition: StoreGateSvc.cxx:112
StoreGateSvc::t2pRegister
StatusCode t2pRegister(const void *const pTrans, SG::DataProxy *const pPers)
forwarded to DataStore
StoreGateSvc::symLink
StatusCode symLink(const T *p2BRegistered, const TLINK *p2BLinked)
make a soft link to the object T* already registered (const link)
xAODMaker::AuxStoreWrapper
Algorithm preparing auxiliary store objects for slimming.
Definition: AuxStoreWrapper.h:41
StoreGateSvc::symLink
StatusCode symLink(const CLID id, const TKEY &key, const CLID linkid)
make a soft link to the object pointed by id/key
DataHandle
an iterator over instances of a given type in StoreGateSvc. It d-casts and caches locally the pointed...
Definition: DataHandle.h:43
IHiveStoreMgr
the interface through which HiveWB control StoreGate instances
Definition: IHiveStoreMgr.h:24
StoreGateSvc::ATLAS_THREAD_SAFE
BadItemList m_badRecords ATLAS_THREAD_SAFE
Definition: StoreGateSvc.h:943
StoreGateSvc::recordAddress
StatusCode recordAddress(const std::string &skey, IOpaqueAddress *pAddress, bool clearAddressFlag=true)
Create a proxy object using an IOpaqueAddress and a transient key.
python.Dumpers.typename
def typename(t)
Definition: Dumpers.py:194
AthenaInternal::py_sg_clearProxyPayload
void py_sg_clearProxyPayload(StoreGateSvc *self, SG::DataProxy *)
Definition: StoreGatePyExt.cxx:458
StoreGateSvc::accessData
DataObject * accessData(const CLID &id) const
find proxy and access its data. Returns 0 to flag failure
Definition: StoreGateSvc.cxx:321
StoreGateSvc::retrieve
StatusCode retrieve(const T *&ptr, const std::string &key) const
Retrieve an object with "key", into a const T*.
StoreGateSvc::tryConstRetrieve
const T * tryConstRetrieve() const
IIOVSvc.h
python.TrigPSCPythonDbSetup.outputLevel
outputLevel
Definition: TrigPSCPythonDbSetup.py:30
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:67
StoreGateSvc::retrieveUniquePrivateCopy
std::unique_ptr< T > retrieveUniquePrivateCopy(const std::string &key)
EXPERTS ONLY: like readPrivateCopy this method returns your own private copy of a data object of type...
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:287
StoreGateSvc::proxies
virtual std::vector< const SG::DataProxy * > proxies() const override final
return the list of all current proxies in store
Definition: StoreGateSvc.cxx:298
Arena.h
Collection of memory allocators with a common lifetime, plus subsystem summary.
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:417
StoreGateSvc::remap
void remap(CLID clid, const TKEY &source, const TKEY &target, off_t index_offset)
Declare a remapping.
PyGate::retrieve
static const T * retrieve(StoreGateSvc *psg, const std::string &key)
Definition: StoreGateSvc.h:1037
StoreGateSvc::sourceID
virtual SG::SourceID sourceID(const std::string &key="EventSelector") const override
Return the metadata source ID for the current event slot.
StoreGateSvc::removeDataAndProxy
StatusCode removeDataAndProxy(const T *pObject)
Remove pObject and its proxy no matter what.
StoreGateSvc::record
StatusCode record(std::unique_ptr< const T > pUnique, const TKEY &key)
Record a const object with a key.
SG_dump
void SG_dump(StoreGateSvc *sg)
These are intended to be easy to call from the debugger.
Definition: StoreGateSvc.cxx:571
StoreID::type
type
Definition: StoreID.h:24
StoreGateSvc::associateAux_impl
bool associateAux_impl(DOBJ *ptr, const std::string &key, const AUXSTORE *) const
AthenaOutputStream
algorithm that marks for write data objects in SG
Definition: AthenaOutputStream.h:55
StoreGateSvc::m_algContextSvc
ServiceHandle< IAlgContextSvc > m_algContextSvc
Algorithm context, for tracking bad calls.
Definition: StoreGateSvc.h:926
copySelective.target
string target
Definition: copySelective.py:37
StoreGateSvc::recordAddress
StatusCode recordAddress(IOpaqueAddress *pAddress, bool clearAddressFlag=true)
Create a proxy object using an IOpaqueAddress.
StoreGateSvc::setStoreID
void setStoreID(StoreID::type id)
set store ID. request forwarded to DataStore:
Definition: StoreGateSvc.cxx:359
SG::SourceID
std::string SourceID
Definition: AthenaKernel/AthenaKernel/SourceID.h:25
IHiveStoreMgr.h
SGWPtr.h
StoreGateSvc::retrieveHighestVersion
StatusCode retrieveHighestVersion(SG::ObjectWithVersion< T > &dobjWithVersion, const TKEY &requestedKey) const
Retrieve version with highest cycle number for a given T,KEY combination If there is only one availab...
Gaudi
=============================================================================
Definition: CaloGPUClusterAndCellDataMonitorOptions.h:273
StoreGateSvc::remove
StatusCode remove(const T *pObject)
Remove pObject, will remove its proxy if not reset only.
StoreGateSvc::associateAux
bool associateAux(DOBJ *, const std::string &key, bool ignoreMissing=true) const
try to associate a data object to its auxiliary store if ignoreMissing=false
StoreGateSvc::retrieve
StatusCode retrieve(T *&ptr, const std::string &key) const
Retrieve an object with "key", into a T*.
copySelective.source
string source
Definition: copySelective.py:32
str
Definition: BTagTrackIpAccessor.cxx:11
IOVSvcDefs.h
defines and typedefs for IOVSvc
StoreGateSvc::hiveProxyDict
virtual ::IProxyDict * hiveProxyDict() override final
implements IHiveStore interface
Definition: StoreGateSvc.h:478
StoreGateSvc::transientProxy
SG::DataProxy * transientProxy(const CLID &id, const std::string &key) const
get proxy with given id and key.
Definition: StoreGateSvc.cxx:314
StoreGateSvc::proxyProviderSvc
IProxyProviderSvc * proxyProviderSvc()
Return current ProxyProviderSvc.
StoreGateSvc::addToStore
virtual StatusCode addToStore(CLID id, SG::DataProxy *proxy) override final
Raw addition of a proxy to the store.
Definition: StoreGateSvc.cxx:260
SG::ObjectWithVersion
associate a data object with its VersionedKey The object is held by a ReadHandle to delay its retriev...
Definition: SGVersionedKey.h:17
DefaultKey.h
checker_macros.h
Define macros for attributes used to control the static checker.
python.PyAthena.obj
obj
Definition: PyAthena.py:132
SG::DataProxy
Definition: DataProxy.h:45
PyObject
_object PyObject
Definition: IPyComponent.h:26
StoreGateSvc::addAlias
StatusCode addAlias(const std::string &aliasKey, SG::DataProxy *dp)
SGHiveEventSlot.h
StoreGateSvc::m_badMutex
mutex_t m_badMutex
Definition: StoreGateSvc.h:948
StoreGateSvc::create
SG::WPtr< T > create(const TKEY &key, ARGS... constructorArgs)
Create an object with one of its constructors and record it with a key.
StoreGateSvc::isSymLinked
bool isSymLinked(const CLID &linkID, SG::DataProxy *dp)
IHiveStore
the interface that provides access to the current hive store
Definition: IHiveStore.h:23
StoreGateSvc::BadListItem
Definition: StoreGateSvc.h:930
StoreGateSvc::recycle
void recycle(DataObject *pBadDObj)
put a bad (unrecordable) dobj away
SG::ConstIterator
Definition: SGIterator.h:164
CLASS_DEF.h
macros to associate a CLID to a type
StoreGateSvc::currentSlot
static SG::HiveEventSlot * currentSlot()
Definition: StoreGateSvc.cxx:86
AthenaInternal::recordObjectToStore
PyObject * recordObjectToStore(StoreGateSvc *, PyObject *, PyObject *, bool, bool, bool)
record object to storegate
Definition: StoreGatePyExt.cxx:476
SG::ConstProxyIterator
ProxyMap::const_iterator ConstProxyIterator
Definition: ProxyMap.h:28
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
StoreGateSvc::record
StatusCode record(T *p2BRegistered, const TKEY &key, bool allowMods, bool resetOnly=true, bool noHist=false)
Record an object with a key, allow possibility of specifying const-access.
ServiceHandle
Definition: ClusterMakerTool.h:37
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
StoreGateSvc::contains
bool contains(const CLID &id, const TKEY &key) const
Look up a keyed object in TDS by CLID.
Generated on Sat Apr 19 2025 21:19:11 for ATLAS Offline Software by   doxygen 1.8.18