The Athena Transient Store API. More...

#include <StoreGateSvc.h>

Inheritance diagram for StoreGateSvc:

Collaboration diagram for StoreGateSvc:

Classes
struct	BadListItem

Public Member Functions
Basic Client Interface: data object creation
template<typename T, typename TKEY, typename... ARGS>
SG::WPtr< T >	create (const TKEY &key, ARGS... constructorArgs)
	Create an object with one of its constructors and record it with a key.
Basic Client Interface: data object registration
template<typename T, typename TKEY>
StatusCode	record (T *p2BRegistered, const TKEY &key)
	Record an object with a key.
template<typename T, typename TKEY>
StatusCode	record (const T *p2BRegistered, const TKEY &key)
	Record a const object with a key.
template<typename T, typename TKEY>
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.
template<typename T, typename TKEY>
StatusCode	record (std::unique_ptr< T > pUnique, const TKEY &key)
	Record an object with a key, take ownership of the unique_ptr obj.
template<typename T, typename TKEY>
StatusCode	record (std::unique_ptr< const T > pUnique, const TKEY &key)
	Record a const object with a key.
template<typename T, typename TKEY>
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.
Basic Client Interface: data object access
template<typename T>
StatusCode	retrieve (const T *&ptr) const
	Retrieve the default object into a const T*.
template<typename T>
StatusCode	retrieve (T *&ptr) const
	Retrieve the default object into a T*.
template<typename T>
T *	retrieve () const
	Variant of the above which doesn't return a status code.
template<typename T>
T *	tryRetrieve () const
	Variant of the above which doesn't print a warning message.
template<typename T>
const T *	tryConstRetrieve () const
template<typename T, typename TKEY> requires KeyConcept<TKEY>
StatusCode	retrieve (const T *&ptr, const TKEY &key) const
	Retrieve an object with "key", into a const T*.
template<typename T>
StatusCode	retrieve (const T *&ptr, const std::string &key) const
	Retrieve an object with "key", into a const T*.
template<typename T, typename TKEY> requires KeyConcept<TKEY>
StatusCode	retrieve (T *&ptr, const TKEY &key) const
	Retrieve an object with "key", into a T*.
template<typename T>
StatusCode	retrieve (T *&ptr, const std::string &key) const
	Retrieve an object with "key", into a T*.
template<typename T, class TKEY>
T *	retrieve (const TKEY &key) const
	Variant of the above which doesn't return a status code.
template<typename T, class TKEY> requires KeyConcept<TKEY>
T *	tryRetrieve (const TKEY &key) const
	Variant of the above which doesn't print a warning message.
template<typename T, class TKEY> requires KeyConcept<TKEY>
const T *	tryConstRetrieve (const TKEY &key) const
template<typename T>
StatusCode	retrieve (SG::ConstIterator< T > &begin, SG::ConstIterator< T > &end) const
	Retrieve all objects of type T: returns an SG::ConstIterator range.
template<typename T, typename TKEY>
bool	contains (const TKEY &key) const
	Look up a keyed object in TDS (compare also tryRetrieve) returns false if object not available in TDS or persistent stores Usage: if (!p_store->contains<Foo>("fooKey")) { ... }.
template<typename T, typename TKEY>
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 Algorithm/AlgTool.
Advanced Client Interface: data object registration
template<typename T, typename TKEY>
StatusCode	overwrite (T *p2BRegistered, const TKEY &key)
	Record an object with a key, overwriting any existing object with same key.
template<typename T, typename TKEY>
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.
template<typename T, typename TKEY>
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.
template<typename T, typename TKEY>
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 unique_ptr obj.
StatusCode	recordAddress (const std::string &skey, CxxUtils::RefCountedPtr< IOpaqueAddress > pAddress, bool clearAddressFlag=true)
	Create a proxy object using an IOpaqueAddress and a transient key.
StatusCode	recordAddress (CxxUtils::RefCountedPtr< IOpaqueAddress > pAddress, bool clearAddressFlag=true)
	Create a proxy object using an IOpaqueAddress.
template<typename T, typename TLINK>
StatusCode	symLink (const T p2BRegistered, TLINK p2BLinked)
	make a soft link to the object T* already registered (non-const)
template<typename T, typename TLINK>
StatusCode	symLink (const T p2BRegistered, const TLINK p2BLinked)
	make a soft link to the object T* already registered (const link)
template<KeyConcept TKEY>
StatusCode	symLink (const CLID id, const TKEY &key, const CLID linkid)
	make a soft link to the object pointed by id/key
template<typename T, typename TKEY, typename AKEY> requires KeyConcept<TKEY> && KeyConcept<AKEY>
StatusCode	setAlias (const T *p2BAliased, const TKEY &key, const AKEY &aliasKey)
	make an alias to a DataObject (provide data type and old key)
template<typename T, typename AKEY> requires KeyConcept<AKEY>
StatusCode	setAlias (const T *p2BAliased, const AKEY &aliasKey)
	make an alias to a DataObject (provide only valid pointer)
StatusCode	setAlias (SG::DataProxy *proxy, const std::string &aliasKey)
	make an alias to a DataObject (provide valid proxy)
StatusCode	setConst (const void *pointer)
	prevent downstream clients from modifying the pointed-at dobj
template<typename T>
StatusCode	remove (const T *pObject)
	Remove pObject, will remove its proxy if not reset only.
template<typename T>
StatusCode	removeDataAndProxy (const T *pObject)
	Remove pObject and its proxy no matter what.
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 Note that the swap is invalidated at event boundaries and/or when somebody clear the store.
IOVSvc interface
template<typename H, typename TKEY>
StatusCode regHandle	ATLAS_NOT_THREAD_SAFE (const DataHandle< H > &handle, const TKEY &key)
template<typename H, typename TKEY>
StatusCode	regHandle (DataHandle< H > &handle, const TKEY &key)
	non-const method - will return an error
template<typename T, typename H, typename TKEY>
StatusCode regFcn	ATLAS_NOT_THREAD_SAFE (StatusCode(T::updFcn)(IOVSVC_CALLBACK_ARGS), const T obj, const DataHandle< H > &handle, const TKEY &key, bool trigger=false)
	register a callback function, with handle + key
template<typename T, typename H, typename TKEY>
StatusCode regFcn	ATLAS_NOT_THREAD_SAFE (StatusCode(T::updFcn)(IOVSVC_CALLBACK_ARGS), const T obj, DataHandle< H > &handle, const TKEY &key, bool trigger=false)
	register a callback function, with handle + key. Non const. Error
template<typename T1, typename T2>
StatusCode regFcn	ATLAS_NOT_THREAD_SAFE (StatusCode(T1::fcn1)(IOVSVC_CALLBACK_ARGS), const T1 obj1, StatusCode(T2::fcn2)(IOVSVC_CALLBACK_ARGS), const T2 obj2, bool trigger=false)
	register a callback function(2) with an already registered function(1)
template<typename T2>
StatusCode regFcn	ATLAS_NOT_THREAD_SAFE (const std::string &toolName, StatusCode(T2::fcn2)(IOVSVC_CALLBACK_ARGS), const T2 obj2, bool trigger=false)
	register a callback function(2) with an already registered AlgTool
virtual SG::DataProxy *	proxy (const void *const pTransient) const override final
	get proxy for a given data object address in memory
virtual SG::DataProxy *	proxy (const CLID &id) const final
	get default proxy with given id. Returns 0 to flag failure
virtual SG::DataProxy *	proxy (const CLID &id, const std::string &key) const override final
	get proxy with given id and key. Returns 0 to flag failure
SG::DataProxy *	proxy (const CLID &id, const char *key) const
	get proxy with given id and key.
virtual StatusCode	addToStore (CLID id, SG::DataProxy *proxy) override final
	Raw addition of a proxy to the store.
virtual SG::DataProxy *	recordObject (SG::DataObjectSharedPtr< DataObject > obj, const std::string &key, bool allowMods, bool returnExisting) override final
	Record an object in the store.
virtual SG::DataProxy *	proxy_exact (SG::sgkey_t sgkey) const override final
	Get proxy given a hashed key+clid.
more proxy dictionary functionality
virtual SG::DataProxy *	proxy (const CLID &id, bool checkValid) const final
	get default proxy with given id, optionally checking validity.
virtual SG::DataProxy *	proxy (const CLID &id, const std::string &key, bool checkValid) const final
	get proxy with given id and key, optionally checking validity.
virtual SG::DataProxy *	proxy (const CLID &id, const char *key, bool checkValid) const final
	get proxy with given id and key, optionally checking validity.
virtual std::vector< const SG::DataProxy * >	proxies () const override final
	return the list of all current proxies in store
std::vector< CLID >	clids () const
	Return all CLIDs in the store.
SG::DataProxy *	transientProxy (const CLID &id, const std::string &key) const
	get proxy with given id and key.
DataObject *	accessData (const CLID &id) const
	find proxy and access its data. Returns 0 to flag failure
DataObject *	accessData (const CLID &id, const std::string &key) const
	find proxy and access its data. Returns 0 to flag failure
void	setProxyProviderSvc (IProxyProviderSvc *pPPSvc)
	associate ProxyProviderSvc to this store
IProxyProviderSvc *	proxyProviderSvc ()
	Return current ProxyProviderSvc.
virtual SG::SourceID	sourceID (const std::string &key="EventSelector") const override
	Return the metadata source ID for the current event slot.
ElementLink remapping
template<class TKEY>
void	remap (CLID clid, const TKEY &source, const TKEY &target, off_t index_offset)
	Declare a remapping.
void	remap_impl (sgkey_t source, sgkey_t target, off_t index_offset)
	Declare a remapping.
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.
Gaudi Standard Service constructors/destructors
	StoreGateSvc (const std::string &name, ISvcLocator *svc)
	Standard Constructor.
virtual	~StoreGateSvc () override
	Standard Destructor.
Gaudi IService implementation
virtual StatusCode	initialize () override
	Service initialization.
virtual StatusCode	stop () override
	Service start.
virtual StatusCode	finalize () override

String <-> int key conversions.
typedef IStringPool::sgkey_t	sgkey_t
virtual sgkey_t	stringToKey (const std::string &str, CLID clid) override final
	Find the key for a string/CLID pair.
virtual const std::string *	keyToString (sgkey_t key) const override final
	Find the string corresponding to a given key.
virtual const std::string *	keyToString (sgkey_t key, CLID &clid) const override final
	Find the string and CLID corresponding to a given key.
virtual void	registerKey (sgkey_t key, const std::string &str, CLID clidid) override final
	Remember an additional mapping from key to string/CLID.

Gaudi IIncidentListener implementation
typedef std::unordered_set< BadListItem, DataObjID_Hasher >	BadItemList
typedef std::mutex	mutex_t
	Protect access to m_bad* members.
typedef std::lock_guard< mutex_t >	lock_t
ServiceHandle< IProxyProviderSvc >	m_pPPSHandle {this, "ProxyProviderSvc", "ProxyProviderSvc"}
	Properties.
ServiceHandle< IIncidentSvc >	m_incSvc {this, "IncidentSvc", "IncidentSvc"}
ServiceHandle< IAlgContextSvc >	m_algContextSvc {this, "AlgContextSvc", "AlgContextSvc"}
Gaudi::Property< bool >	m_DumpStore {this, "Dump", false, "Dump contents at EndEvent"}
Gaudi::Property< bool >	m_ActivateHistory {this, "ActivateHistory", false, "record DataObjects history"}
Gaudi::Property< bool >	m_DumpArena {this, "DumpArena", false, "Dump Arena usage stats"}
StoreID::type	m_storeID
	Cache store type in the facade class.
SmartIF< SGImplSvc >	m_defaultStore
BadItemList m_badRetrieves	ATLAS_THREAD_SAFE
	Remember calls to retrieve and record for a MT store, so we can warn about them during finalize().
BadItemList m_badRecords	ATLAS_THREAD_SAFE
mutex_t	m_badMutex
class	SG::TestHiveStoreSvc
class	SG::HiveMgrSvc
class	AthenaOutputStream
	access proxyRange()
class	xAODMaker::AuxStoreWrapper
	FIXME: access releaseObject.
class	PileUpMergeSvc
	access emptyTrash
class	IOVDbSvc
	access clearProxyPayload
class	IOVSvcTool
class	SG::VarHandleBase
	access typeless_record
void	AthenaInternal::py_sg_clearProxyPayload (StoreGateSvc , SG::DataProxy )
PyObject *	AthenaInternal::recordObjectToStore (StoreGateSvc , PyObject , PyObject *, bool, bool, bool)
virtual void	handle (const Incident &) override final
StatusCode	loadEventProxies ()
	load proxies at begin event
virtual StatusCode	createObj (IConverter cvt, IOpaqueAddress addr, DataObject *&refpObject) override
	Call converter to create an object, with locking.
void	makeCurrent ()
	The current store is becoming the active store.
static SG::HiveEventSlot *	currentSlot ()
SGImplSvc *	currentStore () const
	returns pointer to the current SGImplSvc
StatusCode	proxyRange (const CLID &id, SG::ConstProxyIterator &beg, SG::ConstProxyIterator &end) const
	return a range to all proxies of a given CLID
void	releaseObject (const CLID &id, const std::string &key)
	release object held by proxy, if any.
void	clearProxyPayload (SG::DataProxy *)
	use to reset a proxy (clearing the data object it contains) Unlike DataProxy::reset this method correctly updates SGSvc internals
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 record
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
template<typename T, typename TKEY> requires KeyConcept<TKEY>
StatusCode	record1 (DataObject obj, T pObject, const TKEY &key, bool allowMods, bool resetOnly=true, bool noHist=false)
template<typename T, typename TKEY> requires KeyConcept<TKEY>
StatusCode	overwrite1 (DataObject obj, T pObject, const TKEY &key, bool allowMods, bool noHist=false)
bool	isSymLinked (const CLID &linkID, SG::DataProxy *dp)
StatusCode	addSymLink (const CLID &linkid, SG::DataProxy *dp)
StatusCode	addAlias (const std::string &aliasKey, SG::DataProxy *dp)
std::string	createKey (const CLID &dataID)
	creates a key internally if none specified by client
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
void	recycle (DataObject *pBadDObj)
	put a bad (unrecordable) dobj away
void	emptyTrash ()
	throw away bad objects
StatusCode	removeProxy (SG::DataProxy proxy, const void pTrans, bool forceRemove=false)
	remove proxy from store, unless it is reset only.
StatusCode	t2pRegister (const void const pTrans, SG::DataProxy const pPers)
	forwarded to DataStore
void	t2pRemove (const void *const pTrans)
	forwarded to DataStore
void	msg_update_handler (Gaudi::Details::PropertyBase &outputLevel)
	callback for output level property
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.
void	rememberBadRetrieve (CLID clid, const std::string &key) const
	Remember that retrieve() was called for a MT store.
void	rememberBadRecord (CLID clid, const std::string &key) const
	Remember that retrieve() was called for a MT store.
void	rememberBad (BadItemList &bad, CLID clid, const std::string &key) const
	Remember that retrieve or record was called for a MT store.
void	printBadList (const BadItemList &bad, const std::string &what) const
	Print out a list of bad calls during finalization.
template<class DOBJ>
bool	associateAux (DOBJ *, const std::string &key, bool ignoreMissing=true) const
	try to associate a data object to its auxiliary store if ignoreMissing=false
template<class DOBJ>
bool	associateAux (const DOBJ *, const std::string &key, bool ignoreMissing=true) const
template<class DOBJ, class AUXSTORE>
bool	associateAux_impl (DOBJ ptr, const std::string &key, const AUXSTORE ) const
template<class DOBJ>
bool	associateAux_impl (DOBJ , const std::string &, const SG::NoAuxStore ) const
	StoreGateSvc (const StoreGateSvc &)
StoreGateSvc &	operator= (const StoreGateSvc &)

Advanced Client Interface: data object access
template<typename T, class TKEY>
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 available version of this data object the returned ObjectWithVersion<T>.versionedKey is set to requestedKey NOTICE that this method is significantly slower than retrieve(const T*, const TKEY&) which returns the last recorded version rather than the one with the highest cycle number.
template<typename T, class TKEY>
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 ObjectWithVersion<T> If there is only one available version of this dataObject allVersions[0].versionedKey is set to requestedKey.
template<typename T>
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 T and given key, if available and locked.
template<typename TKEY>
CLID	clid (const TKEY &key) const
	Retrieve the main `CLID` of the object recorded in `StoreGate` with the given "key" WARNING: slow!
template<typename TKEY>
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" WARNING: slow!
template<typename T>
int	typeCount () const
	Return the number of instances of an object of type T int i = p_store->typeCount<T>(); Note that this will return the number of proxies in transient memory only, will not check with proxy providers.
int	typeCount (const CLID &id) const
	Return the number of instances of type T (input CLID)
template<typename TKEY>
bool	contains (const CLID &id, const TKEY &key) const
	Look up a keyed object in TDS by CLID.
template<typename T, typename TKEY>
bool	transientContains (const TKEY &key) const
	Look up a transient data object in TDS only (no Proxy lookup) returns false if object not available in TDS Usage: if (!p_store->contains<Foo>("fooKey")) { ... }.
template<typename TKEY>
bool	transientContains (const CLID &id, const TKEY &key) const
	Look up a transient data object in TDS only by CLID.
std::string	dump () const
	dump objects in store.
void	setStoreID (StoreID::type id)
	set store ID. request forwarded to DataStore:
StoreID::type	storeID () const
	get store ID. request forwarded to DataStore:
template<typename T>
void	keys (std::vector< std::string > &vkeys, bool includeAlias=false, bool onlyValid=true) const
	provide list of all StoreGate keys associated with an object.
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.
virtual::IProxyDict *	hiveProxyDict () override final
	implements IHiveStore interface
static StoreGateSvc *	currentStoreGate ()
	get current StoreGate

IHiveStoreMgr implementation
virtual StatusCode	clearStore (bool forceRemove=false) override final
	clear DataStore contents: called by the event loop mgrs
virtual void	commitNewDataObjects () override final
	Reset handles added since the last call to commit.
void	setDefaultStore (SGImplSvc *pStore)
	set pointer to default event store: used by ActiveStoreSvc
static void	setSlot (SG::HiveEventSlot *pSlot)
	set the hive event slot pointer: used by the event loop mgrs

Detailed Description

The Athena Transient Store API.

Parameters

Dump property (default false): set to call dump() at EndEvent

FolderNameList property (default ""): data folders to be created in this store Caches a pointer to the currently hive store. In most jobs the hive store is simply the default event store (named "StoreGateSvc"). When doing pile-up (and perhaps later on in multi-threaded jobs, the hive store changes during the event loop execution. It is important, for example, that converters always refer to the hive store rather than to the default one.

Author: ATLAS Collaboration

Definition at line 117 of file StoreGateSvc.h.

Member Typedef Documentation

◆ BadItemList

typedef std::unordered_set<BadListItem, DataObjID_Hasher> StoreGateSvc::BadItemList

private

Definition at line 928 of file StoreGateSvc.h.

◆ lock_t

typedef std::lock_guard<mutex_t> StoreGateSvc::lock_t

private

Definition at line 938 of file StoreGateSvc.h.

◆ mutex_t

typedef std::mutex StoreGateSvc::mutex_t

private

Protect access to m_bad* members.

Definition at line 937 of file StoreGateSvc.h.

◆ sgkey_t

typedef IStringPool::sgkey_t StoreGateSvc::sgkey_t

Definition at line 641 of file StoreGateSvc.h.

Constructor & Destructor Documentation

◆ StoreGateSvc() [1/2]

StoreGateSvc::StoreGateSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Standard Constructor.

Definition at line 28 of file StoreGateSvc.cxx.

                                                                 : 
  base_class(name,svc),
  m_storeID (StoreID::findStoreID(name))
{
}

◆ ~StoreGateSvc()

StoreGateSvc::~StoreGateSvc ( )

overridevirtual

Standard Destructor.

Definition at line 35 of file StoreGateSvc.cxx.

36{}

◆ StoreGateSvc() [2/2]

StoreGateSvc::StoreGateSvc ( const StoreGateSvc & )

private

Member Function Documentation

◆ accessData() [1/2]

DataObject * StoreGateSvc::accessData ( const CLID & id ) const

find proxy and access its data. Returns 0 to flag failure

Definition at line 296 of file StoreGateSvc.cxx.

                                             {
  _SGXCALL(accessData, (id), 0);
}

◆ accessData() [2/2]

DataObject * StoreGateSvc::accessData	(	const CLID &	id,
		const std::string &	key ) const

find proxy and access its data. Returns 0 to flag failure

Definition at line 302 of file StoreGateSvc.cxx.

                                                                   {
  _SGXCALL(accessData, (id, key), 0);
}

◆ addAlias()

StatusCode StoreGateSvc::addAlias	(	const std::string &	aliasKey,
		SG::DataProxy *	dp )

private

◆ addAutoSymLinks()

void StoreGateSvc::addAutoSymLinks	(	const std::string &	key,
		CLID	clid,
		SG::DataProxy *	dp,
		const std::type_info *	tinfo,
		bool	warn_nobib = true )

private

Add automatically-made symlinks for DP.

◆ addSymLink()

StatusCode StoreGateSvc::addSymLink	(	const CLID &	linkid,
		SG::DataProxy *	dp )

private

◆ addToStore()

StatusCode StoreGateSvc::addToStore	(	CLID	id,
		SG::DataProxy *	proxy )

finaloverridevirtual

Raw addition of a proxy to the store.

Parameters

id	CLID of object being added.
proxy	proxy to add.

Definition at line 235 of file StoreGateSvc.cxx.

{
  _SGXCALL(addToStore,  (id, proxy), StatusCode::FAILURE);
}

◆ associateAux() [1/2]

template<class DOBJ>

bool StoreGateSvc::associateAux	(	const DOBJ *	,
		const std::string &	key,
		bool	ignoreMissing = true ) const

private

◆ associateAux() [2/2]

template<class DOBJ>

bool StoreGateSvc::associateAux	(	DOBJ *	,
		const std::string &	key,
		bool	ignoreMissing = true ) const

private

try to associate a data object to its auxiliary store if ignoreMissing=false

Returns: false if the aux store is not found.

Parameters

key	The key to use for the lookup.

◆ associateAux_impl() [1/2]

template<class DOBJ>

bool StoreGateSvc::associateAux_impl	(	DOBJ *	,
		const std::string &	,
		const SG::NoAuxStore *	) const

private

◆ associateAux_impl() [2/2]

template<class DOBJ, class AUXSTORE>

bool StoreGateSvc::associateAux_impl	(	DOBJ *	ptr,
		const std::string &	key,
		const AUXSTORE *	) const

private

◆ ATLAS_NOT_THREAD_SAFE() [1/6]

template<typename H, typename TKEY>

StatusCode regHandle StoreGateSvc::ATLAS_NOT_THREAD_SAFE	(	const DataHandle< H > &	handle,
		const TKEY &	key )

◆ ATLAS_NOT_THREAD_SAFE() [2/6]

template<typename T, typename TKEY>

StatusCode bind StoreGateSvc::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 Algorithm/AlgTool.

At the end of every event, or more in general when the data object is not valid anymore, the DataHandle is reset, so that the next time the handle is accessed it will point to the current version of that data object. For example if MyAlg.h has a data member DataHandle<Foo> m_myFoo; after bind is called once per job, usually in MyAlg::initialize: sc = p_store->bind(m_myFoo, "MyFoo"); m_myFoo will provide to access the current MyFoo e.g. in MyAlg::execute(): m_myFoo->useMe();

◆ ATLAS_NOT_THREAD_SAFE() [3/6]

template<typename T2>

StatusCode regFcn StoreGateSvc::ATLAS_NOT_THREAD_SAFE	(	const std::string &	toolName,
		StatusCode(T2::*	fcn2 )(IOVSVC_CALLBACK_ARGS),
		const T2 *	obj2,
		bool	trigger = false )

register a callback function(2) with an already registered AlgTool

◆ ATLAS_NOT_THREAD_SAFE() [4/6]

template<typename T1, typename T2>

StatusCode regFcn StoreGateSvc::ATLAS_NOT_THREAD_SAFE	(	StatusCode(T1::*	fcn1 )(IOVSVC_CALLBACK_ARGS),
		const T1 *	obj1,
		StatusCode(T2::*	fcn2 )(IOVSVC_CALLBACK_ARGS),
		const T2 *	obj2,
		bool	trigger = false )

register a callback function(2) with an already registered function(1)

◆ ATLAS_NOT_THREAD_SAFE() [5/6]

template<typename T, typename H, typename TKEY>

StatusCode regFcn StoreGateSvc::ATLAS_NOT_THREAD_SAFE	(	StatusCode(T::*	updFcn )(IOVSVC_CALLBACK_ARGS),
		const T *	obj,
		const DataHandle< H > &	handle,
		const TKEY &	key,
		bool	trigger = false )

register a callback function, with handle + key

◆ ATLAS_NOT_THREAD_SAFE() [6/6]

template<typename T, typename H, typename TKEY>

StatusCode regFcn StoreGateSvc::ATLAS_NOT_THREAD_SAFE	(	StatusCode(T::*	updFcn )(IOVSVC_CALLBACK_ARGS),
		const T *	obj,
		DataHandle< H > &	handle,
		const TKEY &	key,
		bool	trigger = false )

register a callback function, with handle + key. Non const. Error

◆ clearProxyPayload()

void StoreGateSvc::clearProxyPayload ( SG::DataProxy * proxy )

private

use to reset a proxy (clearing the data object it contains) Unlike DataProxy::reset this method correctly updates SGSvc internals

Definition at line 411 of file StoreGateSvc.cxx.

                                                  {
  _SGVOIDCALL( clearProxyPayload, (proxy) );
}

◆ clearStore()

StatusCode StoreGateSvc::clearStore ( bool forceRemove = false )

finaloverridevirtual

clear DataStore contents: called by the event loop mgrs

Parameters

forceRemove if true remove proxies ignoring their resetOnly flag

Definition at line 425 of file StoreGateSvc.cxx.

{
  StatusCode sc = currentStore()->clearStore(forceRemove);
 
  // Send a notification that the store was cleared.
  if (sc.isSuccess()) {
    m_incSvc->fireIncident(StoreClearedIncident (this, name()));
  }
  return sc;
}

◆ clid()

template<typename TKEY>

CLID StoreGateSvc::clid ( const TKEY & key ) const

Retrieve the main CLID of the object recorded in StoreGate with the given "key" WARNING: slow!

◆ clids() [1/2]

vector< CLID > StoreGateSvc::clids ( ) const

Return all CLIDs in the store.

Definition at line 280 of file StoreGateSvc.cxx.

{
  vector<CLID> nullV;
  _SGXCALL(clids, (), nullV);
}

◆ clids() [2/2]

template<typename TKEY>

std::vector< CLID > StoreGateSvc::clids ( const TKEY & key ) const

Retrieve all the CLID s (including symlinks) of the object recorded in StoreGate with the given "key" WARNING: slow!

◆ commitNewDataObjects()

void StoreGateSvc::commitNewDataObjects ( )

finaloverridevirtual

Reset handles added since the last call to commit.

Definition at line 76 of file StoreGateSvc.cxx.

                                   {
  _SGVOIDCALL(commitNewDataObjects, ());
}

◆ contains() [1/2]

template<typename TKEY>

bool StoreGateSvc::contains	(	const CLID &	id,
		const TKEY &	key ) const

Look up a keyed object in TDS by CLID.

returns false if object not available in TDS or persistent stores Usage: if (!p_store->contains(FooID, "fooKey")) { ... }

◆ contains() [2/2]

template<typename T, typename TKEY>

bool StoreGateSvc::contains ( const TKEY & key ) const

Look up a keyed object in TDS (compare also tryRetrieve) returns false if object not available in TDS or persistent stores Usage: if (!p_store->contains<Foo>("fooKey")) { ... }.

◆ create()

template<typename T, typename TKEY, typename... ARGS>

SG::WPtr< T > StoreGateSvc::create	(	const TKEY &	key,
		ARGS...	constructorArgs )

Create an object with one of its constructors and record it with a key.

Parameters

key	a string (or an object convertible to a string) identifying the object within the event
constructorArgs	a variable list of args passed to the constructor

Returns: a "pointer" to the created object (set to 0 if creation failed) Example: struct Foo { int m_i; int i() const { return m_i; } Foo(int i) : m_i(i) {} }; CLASS_DEF(Foo, 123456, 1); .... auto pFoo = pSG.create<Foo>("aFoo", 23); assert(pFoo->i()==23); assert(pSG.transientContains<Foo>("aFoo"));

◆ createKey()

std::string StoreGateSvc::createKey ( const CLID & dataID )

private

creates a key internally if none specified by client

◆ createObj()

StatusCode StoreGateSvc::createObj	(	IConverter *	cvt,
		IOpaqueAddress *	addr,
		DataObject *&	refpObject )

overridevirtual

Call converter to create an object, with locking.

Parameters

cvt	The converter to call.
addr	Opaque address information for the object to create.
refpObject	Reference to location of the pointer of the created object.

This calls the createObj method on cvt to create the referenced transient object, locking the store during the call.

Definition at line 466 of file StoreGateSvc.cxx.

{
  _SGXCALL( createObj, (cvt, addr, refpObject), StatusCode::FAILURE );
}

◆ currentSlot()

SG::HiveEventSlot * StoreGateSvc::currentSlot ( )

staticprivate

Definition at line 68 of file StoreGateSvc.cxx.

                          { 
  return currentHiveEventSlot; 
}

◆ currentStore()

SGImplSvc * StoreGateSvc::currentStore ( ) const

private

returns pointer to the current SGImplSvc

◆ currentStoreGate()

StoreGateSvc * StoreGateSvc::currentStoreGate ( )

static

get current StoreGate

Definition at line 51 of file StoreGateSvc.cxx.

                                             {
  if (!::currentStoreGate) {
    // this is a static function so we don't have many conveniences
    ISvcLocator *svcLocator = Gaudi::svcLocator();
    SmartIF<StoreGateSvc> sg{svcLocator->service("StoreGateSvc/StoreGateSvc")};
    if ( !sg.isValid() ) {
      throw GaudiException(
          "Could not get \"StoreGateSvc\" to initialize currentStoreGate",
          "StoreGateSvc", StatusCode::FAILURE);
    }
    sg->makeCurrent();
    return sg;
  }
  return ::currentStoreGate;
}

◆ dump()

std::string StoreGateSvc::dump ( ) const

dump objects in store.

request forwarded to DataStore this is triggered at EndEvent setting the Dump property to true

Definition at line 351 of file StoreGateSvc.cxx.

                         {
  std::string nullS = "\n>>>>>>>NO CURRENT STORE<<<<<<<\n";
  _SGXCALL(dump, (), nullS);  
}

◆ emptyTrash()

void StoreGateSvc::emptyTrash ( )

private

throw away bad objects

Definition at line 437 of file StoreGateSvc.cxx.

                         {
  _SGVOIDCALL( emptyTrash, () );
}

◆ finalize()

StatusCode StoreGateSvc::finalize ( )

overridevirtual

Definition at line 182 of file StoreGateSvc.cxx.

                       {
  CHECK( Service::finalize() );
  verbose() << "Finalizing " << name() << endmsg;
  if (m_defaultStore) {
    // m_defaultStore is not active, so ServiceManager won't finalize it!
    CHECK( m_defaultStore->finalize());
  }
 
  printBadList (m_badRetrieves, "retrieve()");
  printBadList (m_badRecords,   "record()");
  return StatusCode::SUCCESS;
}

◆ handle()

void StoreGateSvc::handle ( const Incident & inc )

finaloverridevirtual

Definition at line 175 of file StoreGateSvc.cxx.

                                             {
  currentStore()->handle(inc);
}

◆ hiveProxyDict()

virtual::IProxyDict * StoreGateSvc::hiveProxyDict ( )

inlinefinaloverride

implements IHiveStore interface

Definition at line 474 of file StoreGateSvc.h.

                                                     {
    return StoreGateSvc::currentStore();
  }

◆ initialize()

StatusCode StoreGateSvc::initialize ( )

overridevirtual

Service initialization.

Definition at line 103 of file StoreGateSvc.cxx.

                                       {
 
  // Initialize service:
  CHECK( Service::initialize() );
 
  verbose() << "Initializing " << name() << endmsg;
 
  SmartIF<Gaudi::Interfaces::IOptionsSvc> pJOSvc{serviceLocator()->service("JobOptionsSvc")};
  if ( !pJOSvc.isValid() ) {
    error() << "Failed to retrieve JobOptionsSvc" << endmsg;
  }
  //copy our properties to the prototype (default) SGImplSvc
  const std::string implStoreName = name() + "_Impl";
  for (const Gaudi::Details::PropertyBase* p : getProperties()) {
    pJOSvc->set( implStoreName + "." + p->name(), p->toString() );
  }
 
  //HACK ALERT: using createService rather then the customary service(...,CREATEIF=true) we set our pointer
  // to SGImplSvc early (even before it is initialized). This should help take care of some initialize loops
  // for example when we try to record an address from one of the address providers initialize methods
 
  std::string implStoreFullName = "SGImplSvc/" + implStoreName;
  debug() << "trying to create store " << implStoreFullName << endmsg;
  
  m_defaultStore = serviceLocator().as<ISvcManager>()->createService(implStoreFullName);
 
  if (!m_defaultStore) {
    error() << "Could not create store " << implStoreFullName << endmsg;
    return StatusCode::FAILURE;
  }
  
  if ( m_defaultStore->sysInitialize().isSuccess() ) {
    // If this is the default event store (StoreGateSvc), then declare
    // our arena as the default for memory allocations.
    if (name()  == "StoreGateSvc") {
      m_defaultStore->makeCurrent();
    }
  } else {
    error() << "Could not initialize default store " << implStoreFullName 
            << endmsg;
    return StatusCode::FAILURE;
  }
  if ( !m_incSvc.retrieve().isSuccess() ) {
    error() << "Could not locate IncidentSvc" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // Don't retrieve m_activeStoreSvc here to prevent a possible
  // initialization loop.
 
  const int PRIORITY=100;
  m_incSvc->addListener(this, "EndEvent",PRIORITY);
  m_incSvc->addListener(this, "BeginEvent", PRIORITY);
 
  return StatusCode::SUCCESS;
}

◆ isSymLinked()

bool StoreGateSvc::isSymLinked	(	const CLID &	linkID,
		SG::DataProxy *	dp )

private

◆ keys() [1/2]

void StoreGateSvc::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.

usage: p_store->keys(CLID, vkeys, optionalFlags);

Parameters

id	CLID for which we are requesting list of keys
vkeys	will be filled with the (possibly empty) list of keys
includeAlias	(default false) add alias keys as well
onlyValid	(default true) add only keys of valid dobjs

Definition at line 342 of file StoreGateSvc.cxx.

{ 
  _SGVOIDCALL(keys,(id, vkeys, includeAlias, onlyValid));
} 

◆ keys() [2/2]

template<typename T>

void StoreGateSvc::keys	(	std::vector< std::string > &	vkeys,
		bool	includeAlias = false,
		bool	onlyValid = true ) const

provide list of all StoreGate keys associated with an object.

usage: p_store->keys<T>(vkeys, optional flags);

Parameters

vkeys	will be filled with the (possibly empty) list of keys
includeAlias	(default false) add alias keys as well
onlyValid	(default true) add only keys of valid dobjs

◆ keyToString() [1/2]

const std::string * StoreGateSvc::keyToString ( sgkey_t key ) const

finaloverridevirtual

Find the string corresponding to a given key.

Parameters

key	The key to look up.

Returns: Pointer to the string found, or null. We can find keys as long as the corresponding string was given to either stringToKey() or registerKey().

Definition at line 369 of file StoreGateSvc.cxx.

                                            {
  _SGXCALL( keyToString, (key), 0 );
}

◆ keyToString() [2/2]

const std::string * StoreGateSvc::keyToString	(	sgkey_t	key,
		CLID &	clid ) const

finaloverridevirtual

Find the string and CLID corresponding to a given key.

Parameters

key	The key to look up.
clid[out]	The found CLID.

Returns: Pointer to the string found, or null. We can find keys as long as the corresponding string was given to either stringToKey() or registerKey().

Definition at line 374 of file StoreGateSvc.cxx.

                                                        {
  _SGXCALL( keyToString, (key, clid), 0 );
}

◆ loadEventProxies()

StatusCode StoreGateSvc::loadEventProxies ( )

load proxies at begin event

Definition at line 417 of file StoreGateSvc.cxx.

                               {
  this->makeCurrent();
  _SGXCALL(loadEventProxies, (), StatusCode::FAILURE);
}

◆ makeCurrent()

void StoreGateSvc::makeCurrent ( )

The current store is becoming the active store.

Switch the allocation arena, and call SG::CurrentEventStore::setStore NOTE: No longer only intended to be called by ActiveStoreSvc.

Make this the current StoreGate, switch the allocation arena, and call sg::currenteventstore::setstore

Definition at line 444 of file StoreGateSvc.cxx.

                               {
  ::currentStoreGate = this;
  _SGVOIDCALL (makeCurrent, ());
}

◆ msg_update_handler()

void StoreGateSvc::msg_update_handler ( Gaudi::Details::PropertyBase & outputLevel )

private

callback for output level property

◆ operator=()

StoreGateSvc & StoreGateSvc::operator= ( const StoreGateSvc & )

private

◆ overwrite() [1/4]

template<typename T, typename TKEY>

StatusCode StoreGateSvc::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 unique_ptr obj.

◆ overwrite() [2/4]

template<typename T, typename TKEY>

StatusCode StoreGateSvc::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.

◆ overwrite() [3/4]

template<typename T, typename TKEY>

StatusCode StoreGateSvc::overwrite	(	T *	p2BRegistered,
		const TKEY &	key )

Record an object with a key, overwriting any existing object with same key.

◆ overwrite() [4/4]

template<typename T, typename TKEY>

StatusCode StoreGateSvc::overwrite	(	T *	p2BRegistered,
		const TKEY &	key,
		bool	allowMods,
		bool	noHist = false )

Record an object with a key, overwriting any existing object with same key.

◆ overwrite1()

template<typename T, typename TKEY>
requires KeyConcept<TKEY>

StatusCode StoreGateSvc::overwrite1	(	DataObject *	obj,
		T *	pObject,
		const TKEY &	key,
		bool	allowMods,
		bool	noHist = false )

private

◆ printBadList()

void StoreGateSvc::printBadList	(	const BadItemList &	bad,
		const std::string &	what ) const

private

Print out a list of bad calls during finalization.

Parameters

bad	List of bad calls.
what	Description of the operation.

Definition at line 503 of file StoreGateSvc.cxx.

{
  if (bad.empty()) return;
  std::vector<std::string> lines;
  for (const BadListItem& id : bad) {
    lines.push_back (id.fullKey() + " [" + id.m_algo + "]");
  }
  std::sort (lines.begin(), lines.end());
  warning() << "Called " << what << " on these objects in a MT store" << endmsg;
  for (const std::string& s : lines) {
    warning() << s << endmsg;
  }
}

◆ proxies()

vector< const SG::DataProxy * > StoreGateSvc::proxies ( ) const

finaloverridevirtual

return the list of all current proxies in store

Definition at line 273 of file StoreGateSvc.cxx.

                            {
  vector<const SG::DataProxy*> nullV;
  _SGXCALL(proxies, (), nullV);
}

◆ proxy() [1/7]

DataProxy * StoreGateSvc::proxy ( const CLID & id ) const

finalvirtual

get default proxy with given id. Returns 0 to flag failure

Definition at line 204 of file StoreGateSvc.cxx.

                                        {
  _SGXCALL(proxy, (id), 0);
}

◆ proxy() [2/7]

SG::DataProxy * StoreGateSvc::proxy	(	const CLID &	id,
		bool	checkValid ) const

finalvirtual

get default proxy with given id, optionally checking validity.

Returns: 0 to flag failure

Definition at line 218 of file StoreGateSvc.cxx.

                                                         {
  _SGXCALL(proxy, (id, checkValid), 0);
}

◆ proxy() [3/7]

SG::DataProxy * StoreGateSvc::proxy	(	const CLID &	id,
		const char *	key ) const

get proxy with given id and key.

Returns 0 to flag failure (overload to prevent a char* to be interpreted as a bool.)

◆ proxy() [4/7]

virtual SG::DataProxy * StoreGateSvc::proxy	(	const CLID &	id,
		const char *	key,
		bool	checkValid ) const

inlinefinalvirtual

get proxy with given id and key, optionally checking validity.

Returns: 0 to flag failure (overload to prevent a char* to be interpreted as a bool.)

Definition at line 602 of file StoreGateSvc.h.

603 { return this->proxy(id, std::string(key), checkValid); }

◆ proxy() [5/7]

DataProxy * StoreGateSvc::proxy	(	const CLID &	id,
		const std::string &	key ) const

finaloverridevirtual

get proxy with given id and key. Returns 0 to flag failure

Definition at line 210 of file StoreGateSvc.cxx.

                                                              { 
  _SGXCALL(proxy, (id, key), 0);
}

◆ proxy() [6/7]

SG::DataProxy * StoreGateSvc::proxy	(	const CLID &	id,
		const std::string &	key,
		bool	checkValid ) const

finalvirtual

get proxy with given id and key, optionally checking validity.

Returns: 0 to flag failure

Definition at line 225 of file StoreGateSvc.cxx.

                                                                               {
  _SGXCALL(proxy, (id, key, checkValid), 0);
}

◆ proxy() [7/7]

DataProxy * StoreGateSvc::proxy ( const void *const pTransient ) const

finaloverridevirtual

get proxy for a given data object address in memory

Definition at line 198 of file StoreGateSvc.cxx.

                                                      {
  _SGXCALL(proxy, (pTransient), 0);
}

◆ proxy_exact()

virtual SG::DataProxy * StoreGateSvc::proxy_exact ( SG::sgkey_t sgkey ) const

finaloverridevirtual

Get proxy given a hashed key+clid.

Find an exact match; no handling of aliases, etc. Returns 0 to flag failure.

◆ proxyProviderSvc()

IProxyProviderSvc * StoreGateSvc::proxyProviderSvc ( )

Return current ProxyProviderSvc.

◆ proxyRange()

StatusCode StoreGateSvc::proxyRange	(	const CLID &	id,
		SG::ConstProxyIterator &	beg,
		SG::ConstProxyIterator &	end ) const

private

return a range to all proxies of a given CLID

Definition at line 398 of file StoreGateSvc.cxx.

                                                          {
  _SGXCALL( proxyRange, (id, beg, end), StatusCode::FAILURE );
}

◆ record() [1/6]

template<typename T, typename TKEY>

StatusCode StoreGateSvc::record	(	const T *	p2BRegistered,
		const TKEY &	key )

Record a const object with a key.

◆ record() [2/6]

template<typename T, typename TKEY>

StatusCode StoreGateSvc::record	(	std::unique_ptr< const T >	pUnique,
		const TKEY &	key )

Record a const object with a key.

◆ record() [3/6]

template<typename T, typename TKEY>

StatusCode StoreGateSvc::record	(	std::unique_ptr< T >	pUnique,
		const TKEY &	key )

Record an object with a key, take ownership of the unique_ptr obj.

◆ record() [4/6]

template<typename T, typename TKEY>

StatusCode StoreGateSvc::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.

◆ record() [5/6]

template<typename T, typename TKEY>

StatusCode StoreGateSvc::record	(	T *	p2BRegistered,
		const TKEY &	key )

Record an object with a key.

◆ record() [6/6]

template<typename T, typename TKEY>

StatusCode StoreGateSvc::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.

◆ record1()

template<typename T, typename TKEY>
requires KeyConcept<TKEY>

StatusCode StoreGateSvc::record1	(	DataObject *	obj,
		T *	pObject,
		const TKEY &	key,
		bool	allowMods,
		bool	resetOnly = true,
		bool	noHist = false )

private

◆ recordAddress() [1/2]

StatusCode StoreGateSvc::recordAddress	(	const std::string &	skey,
		CxxUtils::RefCountedPtr< IOpaqueAddress >	pAddress,
		bool	clearAddressFlag = true )

Create a proxy object using an IOpaqueAddress and a transient key.

Definition at line 82 of file StoreGateSvc.cxx.

                                                   {
  _SGXCALL(recordAddress, (skey, std::move(pAddress), clearAddressFlag), StatusCode::FAILURE);
}

◆ recordAddress() [2/2]

StatusCode StoreGateSvc::recordAddress	(	CxxUtils::RefCountedPtr< IOpaqueAddress >	pAddress,
		bool	clearAddressFlag = true )

Create a proxy object using an IOpaqueAddress.

Definition at line 89 of file StoreGateSvc.cxx.

                                                   {
  _SGXCALL(recordAddress, (std::move(pAddress), clearAddressFlag), StatusCode::FAILURE);
}

◆ recordObject()

SG::DataProxy * StoreGateSvc::recordObject	(	SG::DataObjectSharedPtr< DataObject >	obj,
		const std::string &	key,
		bool	allowMods,
		bool	returnExisting )

finaloverridevirtual

Record an object in the store.

Parameters

obj	The data object to store.
key	The key as which it should be stored.
allowMods	If false, the object will be recorded as const.
returnExisting	If true, return proxy if this key already exists. If the object has been recorded under a different key, then make an alias. If the object has been recorded under a different clid, then make a link.

Full-blown record. obj should usually be something deriving from SG::DataBucket.

Returns the proxy for the recorded object; nullptr on failure. If the requested CLID/key combination already exists in the store, the behavior is controlled by returnExisting. If true, then the existing proxy is returned; otherwise, nullptr is returned. In either case, obj is destroyed.

Definition at line 262 of file StoreGateSvc.cxx.

{
  _SGXCALL(recordObject, (std::move(obj), key, allowMods, returnExisting), nullptr);
}

◆ recycle()

void StoreGateSvc::recycle ( DataObject * pBadDObj )

private

put a bad (unrecordable) dobj away

◆ regHandle()

template<typename H, typename TKEY>

StatusCode StoreGateSvc::regHandle	(	DataHandle< H > &	handle,
		const TKEY &	key )

non-const method - will return an error

◆ registerKey()

void StoreGateSvc::registerKey	(	sgkey_t	key,
		const std::string &	str,
		CLID	clidid )

finaloverridevirtual

Remember an additional mapping from key to string/CLID.

Parameters

key	The key to enter.
str	The string to enter.
clid	The CLID associated with the string.

Returns: True if successful; false if the key already corresponds to a different string.

This registers an additional mapping from a key to a string; it can be found later through lookup() on the string. Logs an error if key already corresponds to a different string.

Definition at line 379 of file StoreGateSvc.cxx.

                                        {
  _SGVOIDCALL( registerKey, (key, str, clidid) );
}

◆ releaseObject()

void StoreGateSvc::releaseObject	(	const CLID &	id,
		const std::string &	key )

private

release object held by proxy, if any.

Gives up ownership (somebody else must take charge)

Definition at line 406 of file StoreGateSvc.cxx.

                                                                {
  _SGVOIDCALL( releaseObject, (id, key) );
}

◆ remap()

template<class TKEY>

void StoreGateSvc::remap	(	CLID	clid,
		const TKEY &	source,
		const TKEY &	target,
		off_t	index_offset )

Declare a remapping.

clid Class ID of the container being remapped.

source Key of the container being remapped.

target Key of the container being remapped to.

index_offset Amount by which the index should be adjusted between the two containers.

This can be used to change the container to which ElementLink's (and DataLink's) point on output.

For example, suppose you have two containers of type T, A and B. There possibly are ElementLink's pointing at elements contained in them. You want to change to a single container C, containing the contents of A and B concatenated. To get ElementLink's updated on output, you can do:

m_sg->remap (ClassID_traits<T>::ID(), "A", "C", 0);

m_sg->remap (ClassID_traits<T>::ID(), "B", "C", a.size());

a

static Double_t a

Definition LArPhysWaveHECTool.cxx:38

ClassID_traits::ID

static CLID ID()

Definition Control/AthenaKernel/AthenaKernel/ClassID_traits.h:44

◆ remap_impl()

void StoreGateSvc::remap_impl	(	sgkey_t	source,
		sgkey_t	target,
		off_t	index_offset )

Declare a remapping.

source Key hash of the container being remapped.

target Key hash of the container being remapped to.

index_offset Amount by which the index should be adjusted between the two containers.

Definition at line 385 of file StoreGateSvc.cxx.

                                              {
  _SGVOIDCALL( remap_impl, (source, target, index_offset) );
}

◆ rememberBad()

void StoreGateSvc::rememberBad	(	BadItemList &	bad,
		CLID	clid,
		const std::string &	key ) const

private

Remember that retrieve or record was called for a MT store.

Parameters

bad	The list on which to store the operation.
clid	CLID of the operation.
key	Key of the operation.

Definition at line 480 of file StoreGateSvc.cxx.

{
  if (m_storeID == StoreID::EVENT_STORE && currentHiveEventSlot != nullptr) {
    lock_t lock (m_badMutex);
    std::string algo;
    if (m_algContextSvc.isValid()) {
      if (IAlgorithm* alg = m_algContextSvc->currentAlg()) {
        if (alg->type() == "AthenaOutputStream") return;
        if (alg->type() == "AthIncFirerAlg") return;
        algo = alg->type() + "/" + alg->name();
        bad.insert (BadListItem (clid, key, algo));
      }
    }
  }
}

◆ rememberBadRecord()

void StoreGateSvc::rememberBadRecord	(	CLID	clid,
		const std::string &	key ) const

private

Remember that retrieve() was called for a MT store.

Parameters

clid	CLID of the operation.
key	Key of the operation.

◆ rememberBadRetrieve()

void StoreGateSvc::rememberBadRetrieve	(	CLID	clid,
		const std::string &	key ) const

private

Remember that retrieve() was called for a MT store.

Parameters

clid	CLID of the operation.
key	Key of the operation.

◆ remove()

template<typename T>

StatusCode StoreGateSvc::remove ( const T * pObject )

Remove pObject, will remove its proxy if not reset only.

◆ removeDataAndProxy()

template<typename T>

StatusCode StoreGateSvc::removeDataAndProxy ( const T * pObject )

Remove pObject and its proxy no matter what.

◆ removeProxy()

StatusCode StoreGateSvc::removeProxy	(	SG::DataProxy *	proxy,
		const void *	pTrans,
		bool	forceRemove = false )

private

remove proxy from store, unless it is reset only.

provide pTrans!=0 (must match proxy...) to save time

Parameters

forceRemove remove the proxy no matter what DO NOT USE THIS FUNCTION! IT IS UNSAFE AND IS LIKELY TO BE REMOVED!

Definition at line 449 of file StoreGateSvc.cxx.

                                                       {
  _SGXCALL(removeProxy, (proxy, pTrans, forceRemove), StatusCode::FAILURE);
}

◆ retrieve() [1/9]

template<typename T>

T * StoreGateSvc::retrieve ( ) const

Variant of the above which doesn't return a status code.

Just returns null if the object isn't found.

◆ retrieve() [2/9]

template<typename T>

StatusCode StoreGateSvc::retrieve ( const T *& ptr ) const

Retrieve the default object into a const T*.

◆ retrieve() [3/9]

template<typename T>

StatusCode StoreGateSvc::retrieve	(	const T *&	ptr,
		const std::string &	key ) const

Retrieve an object with "key", into a const T*.

Overload for std::string KEY type

◆ retrieve() [4/9]

template<typename T, typename TKEY>
requires KeyConcept<TKEY>

StatusCode StoreGateSvc::retrieve	(	const T *&	ptr,
		const TKEY &	key ) const

Retrieve an object with "key", into a const T*.

◆ retrieve() [5/9]

template<typename T, class TKEY>

T * StoreGateSvc::retrieve ( const TKEY & key ) const

Variant of the above which doesn't return a status code.

Just returns null if the object isn't found.

◆ retrieve() [6/9]

template<typename T>

StatusCode StoreGateSvc::retrieve	(	SG::ConstIterator< T > &	begin,
		SG::ConstIterator< T > &	end ) const

Retrieve all objects of type T: returns an SG::ConstIterator range.

◆ retrieve() [7/9]

template<typename T>

StatusCode StoreGateSvc::retrieve ( T *& ptr ) const

Retrieve the default object into a T*.

◆ retrieve() [8/9]

template<typename T>

StatusCode StoreGateSvc::retrieve	(	T *&	ptr,
		const std::string &	key ) const

Retrieve an object with "key", into a T*.

Overload for std::string KEY type

◆ retrieve() [9/9]

template<typename T, typename TKEY>
requires KeyConcept<TKEY>

StatusCode StoreGateSvc::retrieve	(	T *&	ptr,
		const TKEY &	key ) const

Retrieve an object with "key", into a T*.

◆ retrieveAllVersions()

template<typename T, class TKEY>

StatusCode StoreGateSvc::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 ObjectWithVersion<T> If there is only one available version of this dataObject allVersions[0].versionedKey is set to requestedKey.

Returns: StatusCode::FAILURE if no dataObject found

◆ retrieveHighestVersion()

template<typename T, class TKEY>

StatusCode StoreGateSvc::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 available version of this data object the returned ObjectWithVersion<T>.versionedKey is set to requestedKey NOTICE that this method is significantly slower than retrieve(const T*, const TKEY&) which returns the last recorded version rather than the one with the highest cycle number.

Returns: StatusCode::FAILURE if no dataObject found

◆ retrieveUniquePrivateCopy()

template<typename T>

std::unique_ptr< T > StoreGateSvc::retrieveUniquePrivateCopy ( const std::string & key )

EXPERTS ONLY: like readPrivateCopy this method returns your own private copy of a data object of type T and given key, if available and locked.

The difference is that it will return you also an object in SG transient memory. Since we are taking ownership of it, the object in SG will be released after retrievePrivateCopy returns, making all cached references to the object potentially invalid and obviously preventing it from being written out. Sequencing becomes critical. Caveat emptor!

Parameters

key	The key to use for the lookup.

Returns: null unique_ptr if the object isn't found or if it is unlocked.

◆ setAlias() [1/3]

template<typename T, typename AKEY>
requires KeyConcept<AKEY>

StatusCode StoreGateSvc::setAlias	(	const T *	p2BAliased,
		const AKEY &	aliasKey )

make an alias to a DataObject (provide only valid pointer)

◆ setAlias() [2/3]

template<typename T, typename TKEY, typename AKEY>
requires KeyConcept<TKEY> && KeyConcept<AKEY>

StatusCode StoreGateSvc::setAlias	(	const T *	p2BAliased,
		const TKEY &	key,
		const AKEY &	aliasKey )

make an alias to a DataObject (provide data type and old key)

◆ setAlias() [3/3]

StatusCode StoreGateSvc::setAlias	(	SG::DataProxy *	proxy,
		const std::string &	aliasKey )

make an alias to a DataObject (provide valid proxy)

◆ setConst()

StatusCode StoreGateSvc::setConst ( const void * pointer )

prevent downstream clients from modifying the pointed-at dobj

Definition at line 96 of file StoreGateSvc.cxx.

                                          {
  _SGXCALL(setConst, (pObject), StatusCode::FAILURE);
}

◆ setDefaultStore()

void StoreGateSvc::setDefaultStore ( SGImplSvc * pStore )

set pointer to default event store: used by ActiveStoreSvc

Definition at line 39 of file StoreGateSvc.cxx.

                                               {
  m_defaultStore = pStore;
}

◆ setProxyProviderSvc()

void StoreGateSvc::setProxyProviderSvc ( IProxyProviderSvc * pPPSvc )

associate ProxyProviderSvc to this store

◆ setSlot()

void StoreGateSvc::setSlot ( SG::HiveEventSlot * pSlot )

static

set the hive event slot pointer: used by the event loop mgrs

Definition at line 44 of file StoreGateSvc.cxx.

                                            { 
  currentHiveEventSlot=pSlot;
  if ( 0 != currentHiveEventSlot) {
    currentHiveEventSlot->pEvtStore->makeCurrent();
  }
}

◆ setStoreID()

void StoreGateSvc::setStoreID ( StoreID::type id )

set store ID. request forwarded to DataStore:

set store id in DataStore:

Definition at line 334 of file StoreGateSvc.cxx.

{
  m_storeID = id;
  // FIXME: should broadcast this to all instances.
  _SGVOIDCALL(setStoreID,(id));
}

◆ setupProxy()

SG::DataProxy * StoreGateSvc::setupProxy	(	const CLID &	dataID,
		const std::string &	gK,
		DataObject *	pDObj,
		bool	allowMods,
		bool	resetOnly )

private

try to locate a proxy or create it if needed

◆ sourceID()

virtual SG::SourceID StoreGateSvc::sourceID ( const std::string & key = "EventSelector" ) const

overridevirtual

Return the metadata source ID for the current event slot.

Parameters

key	SG key of the DataHeader to query. Returns an empty string if no source has been set.

The default version always returns an empty string.

◆ stop()

StatusCode StoreGateSvc::stop ( )

overridevirtual

Service start.

Definition at line 161 of file StoreGateSvc.cxx.

                                 {
  verbose() << "Stop " << name() << endmsg;
  //HACK ALERT: ID event store objects refer to det store objects
  //by setting an ad-hoc priority for event store(s) we make sure they are finalized and hence cleared first
  // see e.g. https://savannah.cern.ch/bugs/index.php?99993
  if (m_defaultStore->store()->storeID() == StoreID::EVENT_STORE) {
    auto pISM = serviceLocator().as<ISvcManager>();
    pISM->setPriority(name(), pISM->getPriority(name())+1).ignore();
    verbose() << "stop: setting service priority to " << pISM->getPriority(name()) 
          << " so that event stores get finalized and cleared before other stores" <<endmsg;
  }
  return StatusCode::SUCCESS;
}

◆ storeID()

StoreID::type StoreGateSvc::storeID ( ) const

get store ID. request forwarded to DataStore:

◆ stringToKey()

StoreGateSvc::sgkey_t StoreGateSvc::stringToKey	(	const std::string &	str,
		CLID	clid )

finaloverridevirtual

Find the key for a string/CLID pair.

Parameters

str	The string to look up.
clid	The CLID associated with the string.

Returns: A key identifying the string. A given string will always return the same key. Will abort in case of a hash collision!

Definition at line 364 of file StoreGateSvc.cxx.

                                                          {
  _SGXCALL( stringToKey, (str, clid), 0 );
}

◆ symLink() [1/3]

template<KeyConcept TKEY>

StatusCode StoreGateSvc::symLink	(	const CLID	id,
		const TKEY &	key,
		const CLID	linkid )

make a soft link to the object pointed by id/key

◆ symLink() [2/3]

template<typename T, typename TLINK>

StatusCode StoreGateSvc::symLink	(	const T *	p2BRegistered,
		const TLINK *	p2BLinked )

make a soft link to the object T* already registered (const link)

◆ symLink() [3/3]

template<typename T, typename TLINK>

StatusCode StoreGateSvc::symLink	(	const T *	p2BRegistered,
		TLINK *	p2BLinked )

make a soft link to the object T* already registered (non-const)

◆ t2pRegister()

StatusCode StoreGateSvc::t2pRegister	(	const void *const	pTrans,
		SG::DataProxy *const	pPers )

private

forwarded to DataStore

◆ t2pRemove()

void StoreGateSvc::t2pRemove ( const void *const pTrans )

private

forwarded to DataStore

◆ transientContains() [1/2]

template<typename TKEY>

bool StoreGateSvc::transientContains	(	const CLID &	id,
		const TKEY &	key ) const

Look up a transient data object in TDS only by CLID.

returns false if object not available in TDS

◆ transientContains() [2/2]

template<typename T, typename TKEY>

bool StoreGateSvc::transientContains ( const TKEY & key ) const

Look up a transient data object in TDS only (no Proxy lookup) returns false if object not available in TDS Usage: if (!p_store->contains<Foo>("fooKey")) { ... }.

◆ transientProxy()

SG::DataProxy * StoreGateSvc::transientProxy	(	const CLID &	id,
		const std::string &	key ) const

get proxy with given id and key.

Does not query ProxyProviderSvc.

Returns: 0 to flag failure

Definition at line 289 of file StoreGateSvc.cxx.

                                                                       {
  _SGXCALL(transientProxy, (id, key), 0);
}

◆ transientSwap()

bool StoreGateSvc::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 Note that the swap is invalidated at event boundaries and/or when somebody clear the store.

Returns: false if swap failed

Definition at line 307 of file StoreGateSvc.cxx.

                                                                            {
  _SGXCALL(transientSwap, (id, keyA, keyB), false);
}

◆ tryConstRetrieve() [1/2]

template<typename T>

const T * StoreGateSvc::tryConstRetrieve ( ) const

◆ tryConstRetrieve() [2/2]

template<typename T, class TKEY>
requires KeyConcept<TKEY>

const T * StoreGateSvc::tryConstRetrieve ( const TKEY & key ) const

◆ tryELRemap()

bool StoreGateSvc::tryELRemap	(	sgkey_t	sgkey_in,
		size_t	index_in,
		sgkey_t &	sgkey_out,
		size_t &	index_out )

finaloverridevirtual

Test to see if the target of an ElementLink has moved.

Parameters

sgkey_in	Original hashed key of the EL.
index_in	Original index of the EL.
sgkey_out[out]	New hashed key for the EL.
index_out[out]	New index for the EL.

Returns: True if there is a remapping; false otherwise.

Definition at line 392 of file StoreGateSvc.cxx.

                                                                 {
  _SGXCALL( tryELRemap, (sgkey_in, index_in, sgkey_out, index_out), false );
}

◆ tryRetrieve() [1/2]

template<typename T>

T * StoreGateSvc::tryRetrieve ( ) const

Variant of the above which doesn't print a warning message.

Just returns null if the object isn't found. Compare to contains

◆ tryRetrieve() [2/2]

template<typename T, class TKEY>
requires KeyConcept<TKEY>

T * StoreGateSvc::tryRetrieve ( const TKEY & key ) const

Variant of the above which doesn't print a warning message.

Just returns null if the object isn't found. Compare to contains

◆ typeCount() [1/2]

template<typename T>

int StoreGateSvc::typeCount ( ) const

Return the number of instances of an object of type T int i = p_store->typeCount<T>();
Note that this will return the number of proxies in transient memory only, will not check with proxy providers.

◆ typeCount() [2/2]

int StoreGateSvc::typeCount ( const CLID & id ) const

Return the number of instances of type T (input CLID)

Definition at line 357 of file StoreGateSvc.cxx.

                                             {
  _SGXCALL(typeCount, (clid), -1);
}

◆ typeless_overwrite()

StatusCode StoreGateSvc::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 )

private

same as typeless_record, allows to overwrite an object in memory or on disk

Definition at line 323 of file StoreGateSvc.cxx.

                                                             {
  _SGXCALL(typeless_overwrite, (id, obj, key, raw_ptr, allowMods, noHist, tinfo), StatusCode::FAILURE);
}

◆ typeless_record()

StatusCode StoreGateSvc::typeless_record	(	DataObject *	obj,
		const std::string &	key,
		const void *const	raw_ptr,
		bool	allowMods,
		bool	resetOnly = true,
		bool	noHist = false )

private

type-less recording of an object with a key, allow possibility of specifying const-access and history record

Definition at line 315 of file StoreGateSvc.cxx.

                                             {
  _SGXCALL(typeless_record, (obj, key, raw_ptr, allowMods, resetOnly, noHist), StatusCode::FAILURE);
}

◆ AthenaInternal::py_sg_clearProxyPayload

void AthenaInternal::py_sg_clearProxyPayload	(	StoreGateSvc *	,
		SG::DataProxy *	)

friend

◆ AthenaInternal::recordObjectToStore

PyObject * AthenaInternal::recordObjectToStore	(	StoreGateSvc *	,
		PyObject *	,
		PyObject *	,
		bool	,
		bool	,
		bool	)

friend

◆ AthenaOutputStream

friend class AthenaOutputStream

friend

access proxyRange()

Definition at line 823 of file StoreGateSvc.h.

◆ IOVDbSvc

friend class IOVDbSvc

friend

access clearProxyPayload

Definition at line 839 of file StoreGateSvc.h.

◆ IOVSvcTool

friend class IOVSvcTool

friend

Definition at line 840 of file StoreGateSvc.h.

◆ PileUpMergeSvc

friend class PileUpMergeSvc

friend

access emptyTrash

Definition at line 837 of file StoreGateSvc.h.

◆ SG::HiveMgrSvc

friend class SG::HiveMgrSvc

friend

Definition at line 817 of file StoreGateSvc.h.

◆ SG::TestHiveStoreSvc

friend class SG::TestHiveStoreSvc

friend

Definition at line 814 of file StoreGateSvc.h.

◆ SG::VarHandleBase

friend class SG::VarHandleBase

friend

access typeless_record

Definition at line 850 of file StoreGateSvc.h.

◆ xAODMaker::AuxStoreWrapper

friend class xAODMaker::AuxStoreWrapper

friend

FIXME: access releaseObject.

Definition at line 830 of file StoreGateSvc.h.

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

BadItemList m_badRetrieves StoreGateSvc::ATLAS_THREAD_SAFE

mutableprivate

Remember calls to retrieve and record for a MT store, so we can warn about them during finalize().

Definition at line 933 of file StoreGateSvc.h.

◆ ATLAS_THREAD_SAFE [2/2]

BadItemList m_badRecords StoreGateSvc::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 934 of file StoreGateSvc.h.

◆ m_ActivateHistory

Gaudi::Property<bool> StoreGateSvc::m_ActivateHistory {this, "ActivateHistory", false, "record DataObjects history"}

private

Definition at line 805 of file StoreGateSvc.h.

805{this, "ActivateHistory", false, "record DataObjects history"};

◆ m_algContextSvc

ServiceHandle<IAlgContextSvc> StoreGateSvc::m_algContextSvc {this, "AlgContextSvc", "AlgContextSvc"}

private

Definition at line 803 of file StoreGateSvc.h.

803{this, "AlgContextSvc", "AlgContextSvc"};

◆ m_badMutex

mutex_t StoreGateSvc::m_badMutex

mutableprivate

Definition at line 939 of file StoreGateSvc.h.

◆ m_defaultStore

SmartIF<SGImplSvc> StoreGateSvc::m_defaultStore

private

Definition at line 812 of file StoreGateSvc.h.

◆ m_DumpArena

Gaudi::Property<bool> StoreGateSvc::m_DumpArena {this, "DumpArena", false, "Dump Arena usage stats"}

private

Definition at line 806 of file StoreGateSvc.h.

806{this, "DumpArena", false, "Dump Arena usage stats"};

◆ m_DumpStore

Gaudi::Property<bool> StoreGateSvc::m_DumpStore {this, "Dump", false, "Dump contents at EndEvent"}

private

Definition at line 804 of file StoreGateSvc.h.

804{this, "Dump", false, "Dump contents at EndEvent"};

◆ m_incSvc

ServiceHandle<IIncidentSvc> StoreGateSvc::m_incSvc {this, "IncidentSvc", "IncidentSvc"}

private

Definition at line 802 of file StoreGateSvc.h.

802{this, "IncidentSvc", "IncidentSvc"};

◆ m_pPPSHandle

ServiceHandle<IProxyProviderSvc> StoreGateSvc::m_pPPSHandle {this, "ProxyProviderSvc", "ProxyProviderSvc"}

private

Properties.

Definition at line 801 of file StoreGateSvc.h.

801{this, "ProxyProviderSvc", "ProxyProviderSvc"};

◆ m_storeID

StoreID::type StoreGateSvc::m_storeID

private

Cache store type in the facade class.

Definition at line 810 of file StoreGateSvc.h.

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

Classes

Public Member Functions

String <-> int key conversions.

Gaudi IIncidentListener implementation

Advanced Client Interface: data object access

IHiveStoreMgr implementation

Detailed Description

Member Typedef Documentation

◆ BadItemList

◆ lock_t

◆ mutex_t

◆ sgkey_t

Constructor & Destructor Documentation

◆ StoreGateSvc() [1/2]

◆ ~StoreGateSvc()

◆ StoreGateSvc() [2/2]

Member Function Documentation

◆ accessData() [1/2]

◆ accessData() [2/2]

◆ addAlias()

◆ addAutoSymLinks()

◆ addSymLink()

◆ addToStore()

◆ associateAux() [1/2]

◆ associateAux() [2/2]

◆ associateAux_impl() [1/2]

◆ associateAux_impl() [2/2]

◆ ATLAS_NOT_THREAD_SAFE() [1/6]

◆ ATLAS_NOT_THREAD_SAFE() [2/6]

◆ ATLAS_NOT_THREAD_SAFE() [3/6]

◆ ATLAS_NOT_THREAD_SAFE() [4/6]

◆ ATLAS_NOT_THREAD_SAFE() [5/6]

◆ ATLAS_NOT_THREAD_SAFE() [6/6]

◆ clearProxyPayload()

◆ clearStore()

◆ clid()

◆ clids() [1/2]

◆ clids() [2/2]

◆ commitNewDataObjects()

◆ contains() [1/2]

◆ contains() [2/2]

◆ create()

◆ createKey()

◆ createObj()

◆ currentSlot()

◆ currentStore()

◆ currentStoreGate()

◆ dump()

◆ emptyTrash()

◆ finalize()

◆ handle()

◆ hiveProxyDict()

◆ initialize()

◆ isSymLinked()

◆ keys() [1/2]

◆ keys() [2/2]

◆ keyToString() [1/2]

◆ keyToString() [2/2]

◆ loadEventProxies()

◆ makeCurrent()

◆ msg_update_handler()

◆ operator=()

◆ overwrite() [1/4]

◆ overwrite() [2/4]

◆ overwrite() [3/4]

◆ overwrite() [4/4]

◆ overwrite1()

◆ printBadList()

◆ proxies()

◆ proxy() [1/7]

◆ proxy() [2/7]

◆ proxy() [3/7]

◆ proxy() [4/7]

◆ proxy() [5/7]

◆ proxy() [6/7]

◆ proxy() [7/7]

◆ proxy_exact()

◆ proxyProviderSvc()

◆ proxyRange()

◆ record() [1/6]