The Athena Transient Store API. More...

#include <SGImplSvc.h>

Inheritance diagram for SGImplSvc:

Public Member Functions
	SGImplSvc (const SGImplSvc &)=delete
SGImplSvc &	operator= (const SGImplSvc &)=delete
Basic Client Interface: data object access
StatusCode	retrieve (CLID clid, SG::detail::IteratorBase &cibegin, SG::detail::IteratorBase &ciend) const
	Retrieve all objects of type T: returns an SG::ConstIterator range.
Advanced Client Interface: data object registration
StatusCode	recordAddress (const std::string &skey, CxxUtils::RefCountedPtr< IOpaqueAddress > pAddress, bool clearAddressFlag=true, const std::vector< CLID > &bases={})
	Create a proxy object using an IOpaqueAddress and a transient key.
StatusCode	recordAddress (CxxUtils::RefCountedPtr< IOpaqueAddress > pAddress, bool clearAddressFlag=true, const std::vector< CLID > &bases={})
	Create a proxy object using an IOpaqueAddress.
StatusCode	symLink (const void *p2BRegistered, CLID linkID)
	make a soft link to the object T* already registered
StatusCode	symLink (const CLID id, const std::string &key, const CLID linkid)
	make a soft link to the object pointed by id/key
StatusCode	setAlias (CLID clid, const std::string &key, const std::string &aliasKey)
	make an alias to a DataObject (provide data type and old key)
StatusCode	setAlias (const void *p2BAliased, const std::string &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
StatusCode	remove (const void *pObject)
	Remove pObject, will remove its proxy if not reset only.
StatusCode	removeDataAndProxy (const void *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.
Advanced Client Interface: data object access
DataObject *	typeless_retrievePrivateCopy (const CLID clid, const std::string &key)
CLID	clid (const std::string &key) const
	Retrieve the main `CLID` of the object recorded in `StoreGate` with the given "key" WARNING: slow!
std::vector< CLID >	clids (const std::string &key) const
	Retrieve all the `CLID` s (including symlinks) of the object recorded in `StoreGate` with the given "key" WARNING: slow!
int	typeCount (const CLID &id) const
	Return the number of instances of type T (input CLID).
bool	contains (const CLID id, const std::string &key) const
	Look up a keyed object in TDS by CLID.
bool	transientContains (const CLID id, const std::string &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:
virtual StoreID::type	storeID () const override
	get store ID. request forwarded to DataStore:
void	keys (const CLID &id, std::vector< std::string > &vkeys, bool includeAlias=false, bool onlyValid=true)
	provide list of all StoreGate keys associated with an object.
virtual::IProxyDict *	hiveProxyDict () override final
	implements IHiveStore interface for compat with Hive
virtual SG::DataProxy *	proxy (const void *const pTransient) const override final
	get proxy for a given data object address in memory
SG::DataProxy *	proxy (const CLID &id) const
	get default proxy with given id.
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
SG::DataProxy *	proxy (const CLID &id, bool checkValid) const
	get default proxy with given id, optionally checking validity.
SG::DataProxy *	proxy (const CLID &id, const std::string &key, bool checkValid) const
	get proxy with given id and key, optionally checking validity.
SG::DataProxy *	proxy (const CLID &id, const char *key, bool checkValid) const
	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
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
	SGImplSvc (const std::string &name, ISvcLocator *svc)
	Standard Constructor.
virtual	~SGImplSvc () override final
	Standard Destructor.
Gaudi IService implementation
virtual StatusCode	initialize () override final
	Service initialization.
virtual StatusCode	reinitialize () override final
	Service reinitialization.
virtual StatusCode	start () override final
	Service start.
virtual StatusCode	stop () override final
	Service stop.
virtual StatusCode	finalize () override final
	Service finalization.
Gaudi IIncidentListener implementation
virtual void	handle (const Incident &) override final
	triggered by Incident service
StatusCode	loadEventProxies ()
	load proxies at begin event

String <-> int key conversions. IStringPool implementation
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.
bool	mergeStringPool (const SGImplSvc &other)
	Merge the string pool from another store into this one.

IHiveStoreMgr implementation
typedef std::recursive_mutex	mutex_t
typedef std::lock_guard< mutex_t >	lock_t
class	IOVDbSvc
	access clearProxyPayload
class	IOVSvcTool
class	StoreGateSvc
class	SG::VarHandleBase
	access typeless_record
class	ActiveStoreSvc
PyObject *	AthenaInternal::recordObjectToStore (StoreGateSvc , PyObject , PyObject *, bool, bool, bool)
void	AthenaInternal::py_sg_clearProxyPayload (StoreGateSvc , SG::DataProxy )
ServiceHandle< IClassIDSvc >	m_pCLIDSvc
ServiceHandle< IConversionSvc >	m_pDataLoader
ServiceHandle< IProxyProviderSvc >	m_pPPSHandle
IProxyProviderSvc *	m_pPPS
ServiceHandle< IHistorySvc >	m_pHistorySvc
SG::DataStore *	m_pStore
std::list< DataObject * >	m_trash
	The Recycle Bin.
ServiceHandle< IIncidentSvc >	m_pIncSvc
	property
bool	m_DumpStore
	Dump Property flag: triggers dump() at EndEvent.
bool	m_ActivateHistory
	Activate the history service.
bool	m_DumpArena
	DumpArena Property flag : trigger m_arena->report() at clearStore.
StringArrayProperty	m_folderNameList
	FolderNameList Property.
ServiceHandle< IIOVSvc >	m_pIOVSvc
	get the IOVSvc "just in time" (breaks recursion at initialize)
bool	m_storeLoaded
	FIXME hack needed by loadEventProxies.
SG::StringPool	m_stringpool
SG::RemapImpl *	m_remap_impl
SG::Arena	m_arena
	Allocation arena to associate with this store.
int	m_slotNumber
	The Hive slot number for this store, or -1 if this isn't a Hive store.
int	m_numSlots
	The total number of slots. 1 if this isn't a Hive store.
std::map< std::thread::id, std::vector< IResetable * > >	m_newBoundHandles
	Keep track of proxies bound since the last call to commitNewDataObjects or clearStore.
mutex_t	m_mutex
mutex_t	m_remapMutex
mutex_t	m_stringPoolMutex
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	setSlotNumber (int slot, int numSlots)
	Set the Hive slot number for this store.
virtual void	boundHandle (IResetable *handle) override final
	Tell the store that a proxy has been bound to a handle.
virtual void	unboundHandle (IResetable *handle) override final
	Tell the store that a handle has been unbound from a proxy.
virtual StatusCode	createObj (IConverter cvt, IOpaqueAddress addr, DataObject *&refpObject) override
	Call converter to create an object, with locking.
StatusCode	record_HistObj (const CLID &id, const std::string &key, const std::string &store, bool allowMods, bool resetOnly=true)
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
StatusCode	typeless_record (DataObject obj, const std::string &key, const void const raw_ptr, bool allowMods, bool resetOnly, bool noHist, const std::type_info *tinfo)
StatusCode	typeless_record (DataObject obj, const std::string &key, const void const raw_ptr, bool allowMods, bool resetOnly, bool noHist, const std::type_info tinfo, SG::DataProxy *proxy_ret, bool noOverwrite)
SG::DataProxy *	record_impl (DataObject obj, const std::string &key, const void const raw_ptr, bool allowMods, bool resetOnly, bool allowOverwrite, const std::type_info *tinfo)
	real recording of an object with a key, allow possibility of specifying const-access
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
SG::DataProxy *	locatePersistent (const SG::TransientAddress *tAddr, bool checkValid=false) const
SG::DataStore *	store ()
const SG::DataStore *	store () const
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
bool	associateAux_impl (SG::AuxVectorBase *ptr, const std::string &key, CLID auxclid) const
bool	associateAux_impl (SG::AuxElement *ptr, const std::string &key, CLID auxclid) const
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	makeCurrent ()
	The current store is becoming the active store.

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

Author: ATLAS Collaboration

Definition at line 103 of file SGImplSvc.h.

Member Typedef Documentation

◆ lock_t

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

private

Definition at line 686 of file SGImplSvc.h.

◆ mutex_t

typedef std::recursive_mutex SGImplSvc::mutex_t

private

Definition at line 685 of file SGImplSvc.h.

◆ sgkey_t

typedef IStringPool::sgkey_t SGImplSvc::sgkey_t

Definition at line 336 of file SGImplSvc.h.

Constructor & Destructor Documentation

◆ SGImplSvc() [1/2]

SGImplSvc::SGImplSvc ( const SGImplSvc & )

delete

◆ SGImplSvc() [2/2]

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

Standard Constructor.

Definition at line 103 of file SGImplSvc.cxx.

  : base_class(name, svc),
    m_pCLIDSvc("ClassIDSvc", name),
    m_pDataLoader("EventPersistencySvc", name),
    m_pPPSHandle("ProxyProviderSvc", name),
    m_pPPS(nullptr),
    m_pHistorySvc("HistorySvc", name),
    m_pStore(new DataStore(*this)),
    m_pIncSvc("IncidentSvc", name),
    m_DumpStore(false), 
    m_ActivateHistory(false),
    m_DumpArena(false),
    m_pIOVSvc("IOVSvc", name),
    m_storeLoaded(false),
    m_remap_impl (new SG::RemapImpl),
    m_arena (name),
    m_slotNumber(-1),
    m_numSlots(1)
{
  //our properties
  declareProperty("ProxyProviderSvc", m_pPPSHandle);
  declareProperty("Dump", m_DumpStore);
  declareProperty("ActivateHistory", m_ActivateHistory);
  declareProperty("DumpArena", m_DumpArena);
  //StoreGateSvc properties
  declareProperty("IncidentSvc", m_pIncSvc);
  //add handler for Service base class property
  m_outputLevel.declareUpdateHandler(&SGImplSvc::msg_update_handler, this);
  
  SG::ArenaHeader* header = SG::ArenaHeader::defaultHeader();
  header->addArena (&m_arena);
}

◆ ~SGImplSvc()

SGImplSvc::~SGImplSvc ( )

finaloverridevirtual

Standard Destructor.

Definition at line 138 of file SGImplSvc.cxx.

                       {
  SG::ArenaHeader* header = SG::ArenaHeader::defaultHeader();
  header->delArena (&m_arena);
 
  delete m_pStore;
  delete m_remap_impl;
}

Member Function Documentation

◆ accessData() [1/2]

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

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

Definition at line 947 of file SGImplSvc.cxx.

{ 
  lock_t lock (m_mutex);
  DataProxy* theProxy(proxy(id, true));
  return (0 == theProxy) ? 0 : theProxy->accessData();
}

◆ accessData() [2/2]

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

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

Definition at line 955 of file SGImplSvc.cxx.

{ 
  lock_t lock (m_mutex);
  DataProxy* theProxy(proxy(id, key, true));
  return (0 == theProxy) ? 0 : theProxy->accessData();
}

◆ addAlias()

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

private

Definition at line 659 of file SGImplSvc.cxx.

{
  if (0 == proxy) {
    SG_MSG_WARNING ("addAlias: no target DataProxy given, Cannot alias to a non-existing object");
    return StatusCode::FAILURE;
  }
 
  // add key to proxy and to ProxyStore
  return m_pStore->addAlias(aliasKey, proxy);
}

◆ addAutoSymLinks()

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

Definition at line 1515 of file SGImplSvc.cxx.

{
  // Automatically make all legal base class symlinks
  if (!tinfo) {
    tinfo = CLIDRegistry::CLIDToTypeinfo (clid);
  }
  const SG::BaseInfoBase* bib = nullptr;
  if (tinfo) {
    bib = SG::BaseInfoBase::find (*tinfo);
  }
  if (!bib) {
    // Could succeed where the previous fails if clid for DataVector<T>
    // but tinfo is for ConstDataVector<DataVector<T> >.
    bib = SG::BaseInfoBase::find (clid);
  }
  if ( bib ) {
    const std::vector<CLID>& bases = bib->get_bases();
    for ( std::size_t i = 0, iMax = bases.size(); i < iMax; ++i ) {
      if ( bases[i] != clid ) {
        if ( addSymLink( bases[i], dp ).isSuccess() ) {
          // register with t2p
          if (dp->object())
            this->t2pRegister( SG::DataProxy_cast( dp, bases[i] ), dp ).ignore();
        }
        else {
          SG_MSG_WARNING ("record_impl: Doing auto-symlinks for object"
                          " with CLID {} and SG key {}:"
                          " Proxy already set for base CLID {}; not making auto-symlink.",
                          clid, key, bases[i]);
        }
      }
    }
 
    // Handle copy conversions.
    {
      for (CLID copy_clid : bib->get_copy_conversions()) {
        if (m_pStore->addSymLink (copy_clid, dp).isFailure()) {
          SG_MSG_WARNING ("record_impl: Doing auto-symlinks for object"
                          " with CLID {} and SG key {}:"
                          " Proxy already set for copy-conversion CLID {}; not making auto-symlink.",
                          clid, key, copy_clid);
        }
      }
    }
  }
  else {
    if (warn_nobib) {
      SG_MSG_WARNING ("record_impl: Could not find suitable SG::BaseInfoBase for CLID [{}] ({}) !\t"
                      "No auto-symlink established !",
                      clid, key);
    }
  }
}

◆ addSymLink()

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

private

Definition at line 582 of file SGImplSvc.cxx.

{ 
  if (0 == dp) {
    SG_MSG_WARNING ("addSymLink: no target DataProxy found. Sorry, can't link to a non-existing data object");
    return StatusCode::FAILURE;
  } 
  StatusCode sc = m_pStore->addSymLink(linkid, dp); 
 
  // If the symlink is a derived->base conversion, then we may have
  // a different transient pointer for the symlink.
  if (sc.isSuccess() && dp->object()) {
    void* baseptr = SG::DataProxy_cast (dp, linkid);
    if (baseptr)
      this->t2pRegister (baseptr, dp).ignore();
  }
  return sc;
}

◆ addToStore()

StatusCode SGImplSvc::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 772 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  return m_pStore->addToStore (id, proxy);
}

◆ associateAux_impl() [1/2]

bool SGImplSvc::associateAux_impl	(	SG::AuxElement *	ptr,
		const std::string &	key,
		CLID	auxclid ) const

private

Definition at line 1750 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  SG_MSG_VERBOSE("called associateAux_impl for key " + key);
  // no Aux store set yet
  if (!ptr->hasStore()) {
    SG::DataProxy* dp = proxy (auxclid, key + "Aux.", true);
    if (dp) {
      if (!dp->isConst()) {
        SG::IAuxStore* pAux = SG::DataProxy_cast<SG::IAuxStore> (dp);
        if (pAux) {
          ptr->setStore (pAux);
          return true;
        }
      }
 
      const SG::IConstAuxStore* pAux = SG::DataProxy_cast<SG::IConstAuxStore> (dp);
      if (pAux) {
        ptr->setStore (pAux);
        return true;
      }
    }
  }
  return false;
}

◆ associateAux_impl() [2/2]

bool SGImplSvc::associateAux_impl	(	SG::AuxVectorBase *	ptr,
		const std::string &	key,
		CLID	auxclid ) const

private

Definition at line 1715 of file SGImplSvc.cxx.

{
  // If we already have the aux store (as should usually be the case), return
  // without taking out the SG lock.  Otherwise, we can deadlock
  // if another thread is also trying to dereference a link to the aux store.
  // (Should _not_ be holding the SG lock when dereferencing the link!)
  if (ptr->hasStore()) return true;
 
  lock_t lock (m_mutex);
  SG_MSG_VERBOSE("called associateAux_impl for key " + key);
  // no Aux store set yet
  if (!ptr->hasStore()) {
    SG::DataProxy* dp = proxy (auxclid, key + "Aux.", true);
    if (dp) {
      if (!dp->isConst()) {
        SG::IAuxStore* pAux = SG::DataProxy_cast<SG::IAuxStore> (dp);
        if (pAux) {
          ptr->setStore (pAux);
          return true;
        }
      }
 
      const SG::IConstAuxStore* pAux = SG::DataProxy_cast<SG::IConstAuxStore> (dp);
      if (pAux) {
        ptr->setStore (pAux);
        return true;
      }
    }
  }
  return false;
}

◆ boundHandle()

void SGImplSvc::boundHandle ( IResetable * handle )

finaloverridevirtual

Tell the store that a proxy has been bound to a handle.

Parameters

proxy The proxy that was bound. The default implementation does nothing.

Definition at line 1592 of file SGImplSvc.cxx.

{
  m_newBoundHandles[std::this_thread::get_id()].push_back (handle);
}

◆ clearProxyPayload()

void SGImplSvc::clearProxyPayload ( SG::DataProxy * dp )

private

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

Definition at line 1402 of file SGImplSvc.cxx.

                                            {
  lock_t lock (m_mutex);
 
  // Remove transient pointer entries for this proxy.
  // But do that only if the proxy has a valid object.
  // Otherwise, we could trigger I/O --- which we don't want since it's useless
  // (we'd just destroy the object immediately).  In some cases it can also
  // lead to a deadlock (see ATR-24482).
  if (dp->isValidObject()) {
    SG::DataProxy::CLIDCont_t clids = dp->transientID();
    SG::DataProxy::CLIDCont_t::const_iterator i(clids.begin()), e(clids.end());
    while (i != e) {
      t2pRemove(SG::DataProxy_cast (dp, *i++));
    }
  }
 
  bool hard_reset = (m_numSlots > 1);
  dp->reset (hard_reset);
}

◆ clearStore()

StatusCode SGImplSvc::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 267 of file SGImplSvc.cxx.

{
#ifdef DEBUG_SGIMPL
  dbg::print(stderr, "SGImplSvc::clearStore(forceRemove={}) on {}\n", forceRemove, name());
#endif
  {
    if (m_DumpArena) {
      std::ostringstream s;
      m_arena.report(s);
      SG_MSG_INFO ("Report for Arena: {}\n{}", m_arena.name(), s.str());
    }
  }
  {
    lock_t lock (m_mutex);
    emptyTrash();
    for (auto& p : m_newBoundHandles)
      p.second.clear();
    assert(m_pStore);
    SG_MSG_DEBUG ("Clearing store with forceRemove={}", forceRemove);
    bool hard_reset = (m_numSlots > 1);
    m_pStore->clearStore(forceRemove, hard_reset, &msgStream(MSG::DEBUG));
    m_storeLoaded=false;  //FIXME hack needed by loadEventProxies
  }
  {
    lock_t remap_lock (m_remapMutex);
    m_remap_impl->m_remaps.clear();
    m_arena.reset();
  }
 
  return StatusCode::SUCCESS;
}

◆ clid()

CLID SGImplSvc::clid ( const std::string & key ) const

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

Definition at line 1481 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  SG::DataStore::ConstStoreIterator s_iter, s_end;
  store()->tRange(s_iter, s_end).ignore();
  
  for ( ; s_iter != s_end; ++s_iter ) {
    if ( s_iter->second.find( key ) != s_iter->second.end() ) {
      return s_iter->first;
    }
  }
 
  return CLID_NULL;
}

◆ clids() [1/2]

std::vector< CLID > SGImplSvc::clids ( ) const

Return all CLIDs in the store.

Definition at line 918 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
 
  using std::distance;
  DataStore::ConstStoreIterator s_iter, s_end;
  store()->tRange(s_iter, s_end).ignore();
 
  std::vector<CLID> clids;
  clids.reserve( distance( s_iter, s_end ) );
 
  for (; s_iter != s_end; ++s_iter ) {
    const CLID id = s_iter->first;
    clids.push_back (id);
  }
 
  return clids;
}

◆ clids() [2/2]

std::vector< CLID > SGImplSvc::clids ( const std::string & key ) const

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

Definition at line 1497 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  std::vector<CLID> clids;
  SG::DataStore::ConstStoreIterator s_iter, s_end;
  store()->tRange(s_iter, s_end).ignore();
  
  for ( ; s_iter != s_end; ++s_iter ) {
    if ( s_iter->second.find( key ) != s_iter->second.end() ) {
      clids.push_back(s_iter->first);
    }
  }
  
  return clids;
}

◆ commitNewDataObjects()

void SGImplSvc::commitNewDataObjects ( )

finaloverridevirtual

Reset handles added since the last call to commit.

Definition at line 1574 of file SGImplSvc.cxx.

                                {
  lock_t lock (m_mutex);
 
  // Reset handles added since the last call to commit.
  bool hard_reset = (m_numSlots > 1);
  std::vector<IResetable*> handles;
  m_newBoundHandles[std::this_thread::get_id()].swap (handles);
  for (IResetable* h : handles)
    h->reset (hard_reset);
}

◆ contains()

bool SGImplSvc::contains	(	const CLID	id,
		const std::string &	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")) { ... }

Definition at line 678 of file SGImplSvc.cxx.

{
  try {
    return (0 != proxy(id, key, true));
  } catch(...) { return false; }
}

◆ createKey()

string SGImplSvc::createKey ( const CLID & dataID )

private

creates a key internally if none specified by client

Definition at line 261 of file SGImplSvc.cxx.

{
  return std::to_string(m_pStore->typeCount(id) + 1);
}

◆ createObj()

StatusCode SGImplSvc::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 1635 of file SGImplSvc.cxx.

{
  // This lock was here originally, but is probably not really needed ---
  // both DataProxy and the I/O components have their own locks.
  // Further, this was observed to cause deadlocks for the detector store,
  // and would in general be expected to be a contention issue.
  //lock_t lock (m_mutex);
  return cvt->createObj (addr, refpObject);
}

◆ dump()

string SGImplSvc::dump ( ) const

dump objects in store.

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

Definition at line 504 of file SGImplSvc.cxx.

{ 
  lock_t lock (m_mutex);
  auto out_buffer = std::string{};
  auto out = std::back_inserter(out_buffer);
  const std::string me = name();
  std::format_to(out, "{}: <<<<<<<<<<<<<<<<< Data Store Dump >>>>>>>>>>>>>>> \n", me);
  std::format_to(out, "{}: SGImplSvc()::dump() which is {} \n", me, m_storeLoaded ? "LOADED" : "NOT LOADED");
 
  DataStore::ConstStoreIterator s_iter, s_end;
  store()->tRange(s_iter, s_end).ignore();
 
  for (; s_iter != s_end; ++s_iter) 
  {
 
    CLID id = s_iter->first;
    int nProxy = store()->typeCount(id);
    std::string tname;
    m_pCLIDSvc->getTypeNameOfID(id, tname).ignore();
    std::format_to(out, "{}: Found {} {} for ClassID {} ({}): \n", me, nProxy, ((nProxy == 1) ? "proxy" : "proxies"), id, tname);
 
    // loop over each type:
    SG::ConstProxyIterator p_iter = (s_iter->second).begin();
    SG::ConstProxyIterator p_end =  (s_iter->second).end();
 
    while (p_iter != p_end) {
      const DataProxy& dp(*p_iter->second);
        std::format_to(out, "{}: flags: ({:7s}, {:8s}, {:6s}) --- data: {:10p} --- key: {}\n", me,
                           (dp.isValid() ? "valid" : "INVALID"),
                           (dp.isConst() ? "locked" : "UNLOCKED"),
                           (dp.isResetOnly() ? "reset" : "DELETE"),
                           dbg::ptr(dp.object()), p_iter->first);
      ++p_iter;
    }
  }
  std::format_to(out, "{}: <<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>> \n", me);
  return out_buffer;
}

◆ emptyTrash()

void SGImplSvc::emptyTrash ( )

private

throw away bad objects

Definition at line 1252 of file SGImplSvc.cxx.

                           {
  lock_t lock (m_mutex);
  while (!m_trash.empty()) {
    m_trash.front()->release();  //delete the bad data object
    m_trash.pop_front();     //remove pointer from list
  }
}

◆ finalize()

StatusCode SGImplSvc::finalize ( )

finaloverridevirtual

Service finalization.

Definition at line 300 of file SGImplSvc.cxx.

                                  {
  SG_MSG_VERBOSE ("Finalizing {}", name());
  
  // Incident service may not work in finalize.
  // Clear this, so that we won't try to send an incident from clearStore.
  (m_pIncSvc.release()).ignore();
  
  const bool FORCEREMOVE(true);
  clearStore(FORCEREMOVE).ignore();
  
  m_stringpool.clear();
  delete m_pStore;
  m_pStore = nullptr;
  delete m_remap_impl;
  m_remap_impl = 0;
  m_arena.erase();
 
  return Service::finalize();
}

◆ handle()

void SGImplSvc::handle ( const Incident & inc )

finaloverridevirtual

triggered by Incident service

Definition at line 232 of file SGImplSvc.cxx.

                                          {
 
  if (inc.type() == "EndEvent") { 
    if (m_DumpStore) {
      SG_MSG_DEBUG("Dumping StoreGate Contents");
      SG_MSG_INFO ("\n{}\n", dump());
    }
  }
}

◆ hiveProxyDict()

virtual::IProxyDict * SGImplSvc::hiveProxyDict ( )

inlinefinaloverride

implements IHiveStore interface for compat with Hive

Definition at line 227 of file SGImplSvc.h.

                                                     {
    return this;
  }

◆ initialize()

StatusCode SGImplSvc::initialize ( )

finaloverridevirtual

Service initialization.

Definition at line 148 of file SGImplSvc.cxx.

                                    {
 
  SG_MSG_VERBOSE ("Initializing {}", name());
 
  CHECK( Service::initialize() );
 
  if (!m_pStore)
    m_pStore = new DataStore (*this);
  if (!m_remap_impl)
    m_remap_impl = new SG::RemapImpl;
 
  //properties accessible from now on
  
  store()->setStoreID(StoreID::findStoreID(name()));
  // If this is the default event store (StoreGateSvc), then declare
  // our arena as the default for memory allocations.
  if (this->storeID() == StoreID::EVENT_STORE) {
    m_arena.makeCurrent();
    SG::CurrentEventStore::setStore (this);
    Atlas::setProxyDictInEventContext (this);
  }
  // set up the incident service:
  if (!(m_pIncSvc.retrieve()).isSuccess()) {
    SG_MSG_ERROR ("Could not locate IncidentSvc ");
    return StatusCode::FAILURE;
  }
 
  // We explicitly do not retrieve m_pIOVSvc and rely on retrieval
  // on first use to avoid an initialization loop here.
 
  CHECK( m_pDataLoader.retrieve() );
  CHECK( m_pCLIDSvc.retrieve() );
 
  if (!m_pPPSHandle.empty()) {
    CHECK( m_pPPSHandle.retrieve() );
    m_pPPS = &*m_pPPSHandle;
  }
 
  if ( m_pPPS && (m_pPPS->preLoadProxies(*m_pStore)).isFailure() )
    {
      SG_MSG_DEBUG(" Failed to preLoad proxies");
      return StatusCode::FAILURE;
    }
 
  // Get hold of History Service
  if (m_ActivateHistory) {
    CHECK( m_pHistorySvc.retrieve() );
  }
 
  return StatusCode::SUCCESS;
}

◆ isSymLinked()

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

private

Definition at line 497 of file SGImplSvc.cxx.

{        
  return (0 != dp) ? dp->transientID(linkID) : false;        
}

◆ keys()

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

provide list of all StoreGate keys associated with an object.

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 488 of file SGImplSvc.cxx.

{ 
  lock_t lock (m_mutex);
  return store()->keys(id, vkeys, includeAlias, onlyValid);
} 

◆ keyToString() [1/2]

const std::string * SGImplSvc::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 1312 of file SGImplSvc.cxx.

{
  lock_t lock (m_stringPoolMutex);
  return m_stringpool.keyToString (key);
}

◆ keyToString() [2/2]

const std::string * SGImplSvc::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 1328 of file SGImplSvc.cxx.

{
  lock_t lock (m_stringPoolMutex);
  return m_stringpool.keyToString (key, clid);
}

◆ loadEventProxies()

StatusCode SGImplSvc::loadEventProxies ( )

load proxies at begin event

Definition at line 242 of file SGImplSvc.cxx.

                                       {
  lock_t lock (m_mutex);
  StatusCode sc(StatusCode::SUCCESS);
  //FIXME this should probably be dealt with by the providers
  if (0 != m_pPPS && !m_storeLoaded) {
    m_storeLoaded = true;
    sc=m_pPPS->loadProxies(*m_pStore);
#ifdef DEBUG_SGIMPL
    dbg::print(stderr, "SGImplSvc::loadEventProxies() LOADED PROXIES on {}\n", name());
  }
  else {
    dbg::print(stderr, "SGImplSvc::loadEventProxies() PROXIES ALREADY LOADED on {}\n", name());
#endif
  }
  return sc;
}

◆ locatePersistent()

DataProxy * SGImplSvc::locatePersistent	(	const SG::TransientAddress *	tAddr,
		bool	checkValid = false ) const

private

Definition at line 1142 of file SGImplSvc.cxx.

{ 
  DataProxy* dp = m_pStore->proxy(tAddr);
  
  if (checkValid && 0 != dp) {
    return dp->isValid() ? dp : 0;
  } else {
    return dp;
  }
}

◆ makeCurrent()

void SGImplSvc::makeCurrent ( )

private

The current store is becoming the active store.

Switch the allocation arena, if needed. Only intended to be called by ActiveStoreSvc.

Switch the allocation arena, if needed, and call SG::CurrentEventStore::setStore.

Definition at line 1616 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  m_arena.makeCurrent();
  SG::CurrentEventStore::setStore (this);
}

◆ mergeStringPool()

bool SGImplSvc::mergeStringPool ( const SGImplSvc & other )

Merge the string pool from another store into this one.

Parameters

other The other store.

In case of collisions, the colliding entries are skipped, and false is returned. If no collisions, then true is returned.

Definition at line 1368 of file SGImplSvc.cxx.

{
  // We should hold m_stringPoolMutex before touching the pool.
  // But if we acquire the locks for both this and the other store,
  // we risk a deadlock.  So first copy the other pool, so that we
  // don't need to hold both locks at the same time.
  SG::StringPool tmp;
  {
    lock_t lock (other.m_stringPoolMutex);
    tmp = other.m_stringpool;
  }
  lock_t lock (m_stringPoolMutex);
  return m_stringpool.merge (tmp);
}

◆ msg_update_handler()

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

private

callback for output level property

Definition at line 1202 of file SGImplSvc.cxx.

{
  setUpMessaging();
  updateMsgStreamOutputLevel( outputLevel() );
  msgSvc()->setOutputLevel(name(), outputLevel());
}

◆ operator=()

SGImplSvc & SGImplSvc::operator= ( const SGImplSvc & )

delete

◆ proxies()

std::vector< const SG::DataProxy * > SGImplSvc::proxies ( ) const

finaloverridevirtual

return the list of all current proxies in store

Definition at line 908 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  const std::vector<SG::DataProxy*>& proxies = store()->proxies();
  std::vector<const SG::DataProxy*> ret (proxies.begin(), proxies.end());
  return ret;
}

◆ proxy() [1/7]

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

get default proxy with given id.

Returns 0 to flag failure Deprecated for the event store.

Definition at line 705 of file SGImplSvc.cxx.

{ 
  return proxy(id, false);
}

◆ proxy() [2/7]

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

get default proxy with given id, optionally checking validity.

Returns: 0 to flag failure

Check if it is valid

Definition at line 711 of file SGImplSvc.cxx.

{ 
  DataProxy* dp = nullptr;
  {
    lock_t lock (m_mutex);
    dp = m_pStore->proxy(id);
    if (0 == dp && 0 != m_pPPS) {
      SG::DataStore* pStore ATLAS_THREAD_SAFE = m_pStore;
      dp = m_pPPS->retrieveProxy(id, string("DEFAULT"), *pStore);
    }
  }
  // Be sure to release the lock before this.
  // isValid() may call back to the store, so we could otherwise deadlock..
  if (checkValid && 0 != dp) {
    // FIXME: For keyless retrieve, this checks only the first instance
    // of the CLID in store. If that happens to be invalid, but the second
    // is valid - this does not work (when checkValid is requested).
    return dp->isValid() ? dp : 0;
  }
  return dp;
}

◆ proxy() [3/7]

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

inline

get proxy with given id and key.

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

Definition at line 246 of file SGImplSvc.h.

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

◆ proxy() [4/7]

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

inline

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 298 of file SGImplSvc.h.

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

◆ proxy() [5/7]

DataProxy * SGImplSvc::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 735 of file SGImplSvc.cxx.

{
  return proxy(id, key, false);
}

◆ proxy() [6/7]

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

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

Returns: 0 to flag failure

Definition at line 741 of file SGImplSvc.cxx.

{ 
  DataProxy* dp = nullptr;
  {
    lock_t lock (m_mutex);
    dp = m_pStore->proxy(id, key);
#ifdef DEBUG_SGIMPL
    if (!dp) dbg::print(stderr, "::SGImplSvc::proxy(name={}, key={}): data proxy is null, m_pPPS is {}\n", this->name(), key, m_pPPS == 0 ? "NULL" : "NOT NULL");
#endif
    if (0 == dp && 0 != m_pPPS) {
      SG::DataStore* pStore ATLAS_THREAD_SAFE = m_pStore;
      dp = m_pPPS->retrieveProxy(id, key, *pStore);
#ifdef DEBUG_SGIMPL
      if (!dp) dbg::print(stderr, "::SGImplSvc::proxy(name={}, key={}): data proxy is still null\n", this->name(), key);
#endif
    }
  }
  // Be sure to release the lock before this.
  // isValid() may call back to the store, so we could otherwise deadlock..
  if (checkValid && 0 != dp && !(dp->isValid())) {
    dp = 0;
  }
  return dp;
}

◆ proxy() [7/7]

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

finaloverridevirtual

get proxy for a given data object address in memory

Definition at line 696 of file SGImplSvc.cxx.

{
  // No lock needed here --- the T2pmap held by DataStore has its own locking
  // (and we were seeing contention here).
  //lock_t lock (m_mutex);
  return m_pStore->locatePersistent(pTransient); 
}

◆ proxy_exact()

SG::DataProxy * SGImplSvc::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.

Definition at line 885 of file SGImplSvc.cxx.

{
  return m_pStore->proxy_exact_unlocked (sgkey, m_mutex);
}

◆ proxyProviderSvc()

IProxyProviderSvc * SGImplSvc::proxyProviderSvc ( )

Return current ProxyProviderSvc.

◆ record_HistObj()

StatusCode SGImplSvc::record_HistObj	(	const CLID &	id,
		const std::string &	key,
		const std::string &	store,
		bool	allowMods,
		bool	resetOnly = true )

private

Definition at line 1264 of file SGImplSvc.cxx.

                                                          {
 
  DataHistory *dho;
  dho = m_pHistorySvc->createDataHistoryObj( id, key, store );
 
  std::string idname;
  StatusCode sc = m_pCLIDSvc->getTypeNameOfID(id, idname);
  if (sc.isFailure() || idname.empty() ) { 
    idname = std::to_string(id);
  }
  idname += '/';
  idname += key;
 
  DataObject* obj = SG::asStorable(dho);
  
  const bool ALLOWOVERWRITE(false);
  if (record_impl(obj, idname, dho, allowMods, resetOnly, ALLOWOVERWRITE,
                  &typeid(DataHistory)) == nullptr)
    return StatusCode::FAILURE;
  return StatusCode::SUCCESS;
}

◆ record_impl()

SG::DataProxy * SGImplSvc::record_impl	(	DataObject *	obj,
		const std::string &	key,
		const void *const	raw_ptr,
		bool	allowMods,
		bool	resetOnly,
		bool	allowOverwrite,
		const std::type_info *	tinfo )

private

real recording of an object with a key, allow possibility of specifying const-access

Definition at line 1072 of file SGImplSvc.cxx.

{
  CLID clid = pDObj->clID();
  std::string rawKey(key);
  if (!allowOverwrite && m_pPPS) {
    //do not overwrite a persistent object
    DataProxy* dp = m_pStore->proxy (clid, rawKey);
    if (!dp) {
      dp = m_pPPS->retrieveProxy(clid, rawKey, *m_pStore);
    }
    if (dp && dp->provider()) {
      std::string clidTypeName; 
      m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
      SG_MSG_WARNING ("record_impl: you are recording an object with key {}, type {} (CLID {})\n"
                      " There is already a persistent version of this object."
                      " Recording a duplicate may lead to unreproducible results and it is deprecated.",
                      rawKey, clidTypeName, clid);
    }
  }
  //now check whether raw_ptr has already been recorded
  //We need to do this before we create the bucket, the proxy etc
  SG::DataProxy* dp(proxy(raw_ptr));
  if (0 != dp) {
    std::string clidTypeName; 
    m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
    SG_MSG_WARNING ("record_impl: failed for key={}, type {} (CLID {})\n"
                    " object @{} already in store with key={}. Will not record a duplicate!",
                    rawKey, clidTypeName, clid, raw_ptr, dp->name());
    if (pDObj != dp->object()) {
      DataBucketBase* pDBB(dynamic_cast<DataBucketBase*>(pDObj));
      if (!pDBB) std::abort();
      pDBB->relinquish(); //don't own the data obj already recorded!
    }
    this->recycle(pDObj);
    return nullptr;
  }
 
 
  // setup the proxy
  dp = setupProxy( clid, rawKey, pDObj, allowMods, resetOnly );
  if ( 0 == dp ) {
    std::string clidTypeName; 
    m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
    SG_MSG_WARNING ("record_impl: Problem setting up the proxy for object @{}\n"
                    " recorded with key {} of type {} (CLID {}) in DataObject @{}",
                    raw_ptr, rawKey, clidTypeName, clid,
                    static_cast<void*>(pDObj));
 
    return nullptr;
  }
 
  // record in t2p:
  if ( !(this->t2pRegister( raw_ptr, dp )).isSuccess() ) {
    std::string clidTypeName; 
    m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
    SG_MSG_WARNING ("record_impl: can not add to t2p map object @{}\n"
                    " with key {} of type {} (CLID {})",
                    raw_ptr, rawKey, clidTypeName, clid);
    return nullptr;
  }
 
  addAutoSymLinks (rawKey, clid, dp, tinfo);
 
  return dp;
}

◆ recordAddress() [1/2]

StatusCode SGImplSvc::recordAddress	(	const std::string &	skey,
		CxxUtils::RefCountedPtr< IOpaqueAddress >	pAddress,
		bool	clearAddressFlag = true,
		const std::vector< CLID > &	bases = {} )

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

Definition at line 333 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  assert(0 != pAddress);
  CLID dataID = pAddress->clID();
 
  if (dataID == 0)
    {
      SG_MSG_WARNING ("recordAddress: Invalid Class ID found in IOpaqueAddress @{}. IOA will not be recorded",
                      static_cast<void*>(pAddress.get()));
      return StatusCode::FAILURE;
    }
 
  //do not overwrite a persistent object
  if (m_pPPS) {
    DataProxy* dp = m_pStore->proxy (dataID, skey);
    if (!dp) {
      dp = m_pPPS->retrieveProxy(dataID, skey, *m_pStore);
    }
    if (dp && dp->provider()) {
      std::string clidTypeName; 
      m_pCLIDSvc->getTypeNameOfID(dataID, clidTypeName).ignore();
      SG_MSG_WARNING ("recordAddress: failed for key={}, type  (CLID {})\n" 
                      " there is already a persistent version of this object. Will not record a duplicate! ",
                      skey, clidTypeName, dataID);
      return StatusCode::FAILURE;
    }
  }
 
  // Check if a key already exists
  DataProxy* dp = m_pStore->proxy_exact(dataID, skey);
  if (0 == dp && 0 != m_pPPS) {
    dp = m_pPPS->retrieveProxy(dataID, skey, *m_pStore);
  }
 
  // Now treat the various cases:
  if (0 == dp) 
    {
      // create the proxy object and register it
      dp = new DataProxy (TransientAddress (dataID, skey,
                                            std::move(pAddress),
                                            clearAddressFlag),
                          m_pDataLoader.get(), true, true);
      m_pStore->addToStore(dataID, dp).ignore();
 
      addAutoSymLinks (skey, dataID, dp, 0, false);
 
      // Add extra bases.
      for (CLID b : bases) {
        if (addSymLink (b, dp).isFailure()) {
          warning() << std::format ("Can't add extra base {} for object {}/{}",
                                    b, dataID, skey) << endmsg;
        }
      }
    }
  else if ((0 != dp) && (0 == dp->address()))
    // Note: intentionally not checking dp->isValidAddress()
    {
      // Update proxy with IOpaqueAddress
      dp->setAddress(std::move(pAddress));
    }
  else
    {
      string errType;
      m_pCLIDSvc->getTypeNameOfID(dataID, errType).ignore();
      SG_MSG_WARNING ("recordAddress: preexisting proxy @{} with non-NULL IOA found for key  type {} ({}). \n"
                      "Cannot record IOpaqueAddress @{}",
                      static_cast<void*>(dp), skey, errType, dataID,
                      static_cast<void*>(pAddress.get()));
      return StatusCode::FAILURE;
    }
 
  return StatusCode::SUCCESS;
 
}    

◆ recordAddress() [2/2]

StatusCode SGImplSvc::recordAddress	(	CxxUtils::RefCountedPtr< IOpaqueAddress >	pAddress,
		bool	clearAddressFlag = true,
		const std::vector< CLID > &	bases = {} )

Create a proxy object using an IOpaqueAddress.

Definition at line 416 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  assert(0 != pAddress);
 
  CLID dataID = pAddress->clID();
 
  string gK = (pAddress->par())[1];   // transient name by convention
  if (gK.empty()) gK = (pAddress->par())[0];   // FIXME backward compatibility
  if (gK.empty()) gK = createKey(dataID);
 
  return this->recordAddress(gK, std::move(pAddress), clearAddressFlag, bases);
}    

◆ recordObject()

SG::DataProxy * SGImplSvc::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 799 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  const void* raw_ptr = obj.get();
  const std::type_info* tinfo = nullptr;
  
  if (DataBucketBase* bucket = dynamic_cast<DataBucketBase*> (obj.get())) {
    raw_ptr = bucket->object();
    tinfo = &bucket->tinfo();
  }
 
  if (returnExisting) {
    SG::DataProxy* proxy = this->proxy (obj->clID(), key);
    if (proxy && proxy->isValid()) return proxy;
 
    // Look for the same object recorded under a different key/clid.
    proxy = this->proxy (raw_ptr);
    if (proxy && proxy->isValid()) {
      if (proxy->transientID (obj->clID())) {
        // CLID matches.  Make an alias.
        if (addAlias (key, proxy).isFailure()) {
          CLID clid = proxy->clID();
          std::string clidTypeName; 
          m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
          SG_MSG_WARNING ("SGImplSvc::recordObject: addAlias fails for object {} [{}] {} and new key {}",
                          clid, clidTypeName, proxy->name(), key);
          proxy = nullptr;
        }
      }
 
      else if (key == proxy->name() || proxy->hasAlias(key) > 0)
      {
        // key matches.  Make a symlink.
        if (addSymLink (obj->clID(), proxy).isFailure()) {
          CLID clid = proxy->clID();
          std::string clidTypeName; 
          m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
          CLID newclid = obj->clID();
          std::string newclidTypeName; 
          m_pCLIDSvc->getTypeNameOfID(newclid, newclidTypeName).ignore();
          SG_MSG_ERROR ("SGImplSvc::recordObject:"
                        " addSymLink fails for object {} [{}] {} and new clid {} [{}]",
                        clid, clidTypeName, proxy->name(),
                        newclid, newclidTypeName);
          proxy = nullptr;
        }
      }
 
      else {
        CLID clid = proxy->clID();
        std::string clidTypeName; 
        m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
        CLID newclid = obj->clID();
        std::string newclidTypeName; 
        m_pCLIDSvc->getTypeNameOfID(newclid, newclidTypeName).ignore();
        SG_MSG_ERROR ("SGImplSvc::recordObject:"
                      " existing object found with {} [{}] {} but neither"
                      " clid {} [{}] nor key {} match.",
                      clid, clidTypeName, proxy->name(),
                      newclid, newclidTypeName, key);
        proxy = nullptr;
      }
 
      return proxy;
    }
  }
 
  const bool resetOnly = true;
  const bool noHist = false;
  SG::DataProxy* proxy = nullptr;
  if (this->typeless_record (obj.get(), key, raw_ptr,
                             allowMods, resetOnly, noHist, tinfo,
                             &proxy, true).isFailure())
    {
      return nullptr;
    }
  return proxy;
}

◆ recycle()

void SGImplSvc::recycle ( DataObject * pBadDObj )

private

put a bad (unrecordable) dobj away

Definition at line 1245 of file SGImplSvc.cxx.

                                            {
  assert(pBadDObj);
  pBadDObj->addRef(); 
  m_trash.push_back(pBadDObj);
}

◆ registerKey()

void SGImplSvc::registerKey	(	sgkey_t	key,
		const std::string &	str,
		CLID	clid )

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 1347 of file SGImplSvc.cxx.

{
  lock_t lock (m_stringPoolMutex);
  if (!m_stringpool.registerKey (key, str, clid)) {
    CLID clid2;
    const std::string* str2 = m_stringpool.keyToString (key, clid2);
    SG_MSG_WARNING ("The numeric key {} maps to multiple string key/CLID pairs: {}/{} and {}/{}",
                    key, *str2, clid2, str, clid);
  }
}

◆ reinitialize()

StatusCode SGImplSvc::reinitialize ( )

finaloverridevirtual

Service reinitialization.

Definition at line 321 of file SGImplSvc.cxx.

                                      {
  SG_MSG_VERBOSE ("Reinitializing {}", name());
  const bool FORCEREMOVE(true);
  clearStore(FORCEREMOVE).ignore();
  //not in v20r2p2! return Service::reinitialize();
  return StatusCode::SUCCESS;
}

◆ releaseObject()

void SGImplSvc::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 1385 of file SGImplSvc.cxx.

                                                             {
  lock_t lock (m_mutex);
  DataProxy *pP(0);
  if (0 != (pP = proxy(id, key))) {
    // remove all entries from t2p map
    SG::DataProxy::CLIDCont_t clids = pP->transientID();
    SG::DataProxy::CLIDCont_t::const_iterator i(clids.begin()), e(clids.end());
    while (i != e) t2pRemove(SG::DataProxy_cast (pP, *i++));
    DataBucketBase *pDBB(dynamic_cast<DataBucketBase*>(pP->object()));
    //tell the bucket to let go of the data object
    if (0 != pDBB) pDBB->relinquish(); //somebody else better took ownership
    bool hard_reset = (m_numSlots > 1);
    pP->reset (hard_reset);
  }
}

◆ remap_impl()

void SGImplSvc::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 1430 of file SGImplSvc.cxx.

{
  lock_t lock (m_remapMutex);
  SG::RemapImpl::remap_t payload;
  payload.target = target;
  payload.index_offset = index_offset;
  m_remap_impl->m_remaps[source] = payload;
}

◆ remove()

StatusCode SGImplSvc::remove ( const void * pObject )

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

Definition at line 1228 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  return removeProxy(proxy(pObject), pObject);
}

◆ removeDataAndProxy()

StatusCode SGImplSvc::removeDataAndProxy ( const void * pObject )

Remove pObject and its proxy no matter what.

Definition at line 1237 of file SGImplSvc.cxx.

{        
  lock_t lock (m_mutex);
  const bool FORCEREMOVE(true);          
  return removeProxy(proxy(pObject), pObject, FORCEREMOVE);      
}

◆ removeProxy()

StatusCode SGImplSvc::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

Definition at line 1155 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  // check if valid proxy
  if (0 == proxy) return StatusCode::FAILURE;
 
  if (0 == pTrans) {
    DataBucketBase* bucket = dynamic_cast<DataBucketBase*>(proxy->object());
    if (bucket) pTrans = bucket->object();
  }
 
  // remove all entries from t2p map
  //  --- only if the proxy actually has an object!
  //      otherwise, we can trigger I/O.
  //      besides being useless here, we can get deadlocks if we
  //      call into the I/O code while holding the SG lock.
  if (proxy->isValidObject()) {
    this->t2pRemove(pTrans);
    SG::DataProxy::CLIDCont_t clids = proxy->transientID();
    for (SG::DataProxy::CLIDCont_t::const_iterator i = clids.begin();
         i != clids.end();
         ++i)
    {
      void* ptr = SG::DataProxy_cast (proxy, *i);
      this->t2pRemove(ptr);
    }
  }
 
  // remove from store
  return m_pStore->removeProxy(proxy, forceRemove, true);
}

◆ retrieve()

StatusCode SGImplSvc::retrieve	(	CLID	clid,
		SG::detail::IteratorBase &	cibegin,
		SG::detail::IteratorBase &	ciend ) const

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

Definition at line 1685 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  SG::ConstProxyIterator first;
  SG::ConstProxyIterator end;
 
  if (!(m_pStore->pRange(clid,first,end)).isSuccess()) {
    std::string typnam;
    m_pCLIDSvc->getTypeNameOfID(clid, typnam).ignore();
    SG_MSG_DEBUG("retrieve(range): no object found of type {} (CLID {})",
                 typnam, clid);
  }
 
  (ciend.setState(end, end, true)).ignore();
  
  if (!(cibegin.setState(first, end, true)).isSuccess()) {
    std::string typnam;
    m_pCLIDSvc->getTypeNameOfID(clid, typnam).ignore();
    SG_MSG_DEBUG("retrieve(range): Can't initialize iterator for object range " 
                 " of type {} (CLID {})",
                 typnam, clid);
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

◆ setAlias() [1/3]

StatusCode SGImplSvc::setAlias	(	CLID	clid,
		const std::string &	key,
		const std::string &	aliasKey )

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

Definition at line 626 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
 
  SG::DataProxy* dp(0); 
  dp = proxy(clid, key);
  if (0 == dp) {
    error() << "setAlias: problem setting alias " 
          << std::string(aKey) << '\n'
          << "DataObject does not exist, record before setting alias."
          << endmsg;
    return StatusCode::FAILURE;
  }
 
  StatusCode sc = addAlias(aKey, dp);
  if (sc.isFailure()) {
    error() << "setAlias: problem setting alias " 
          << (std::string)aKey << '\n'
          << "DataObject does not exist, record before setting alias."
          << endmsg;
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

◆ setAlias() [2/3]

StatusCode SGImplSvc::setAlias	(	const void *	p2BAliased,
		const std::string &	aliasKey )

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

Definition at line 601 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
 
  SG::DataProxy* dp(0);
  dp = proxy(pObject);
  if (0 == dp) {
    SG_MSG_ERROR ("setAlias: problem setting alias {}\n"
                  "DataObject does not exist, record before setting alias.",
                  aliasKey);
    return StatusCode::FAILURE;
  }
 
  StatusCode sc = addAlias(aliasKey, dp);
  if (sc.isFailure()) {
    SG_MSG_ERROR ("setAlias: problem setting alias {}\n" 
                  "DataObject does not exist, record before setting alias.",
                  aliasKey);
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

◆ setAlias() [3/3]

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

make an alias to a DataObject (provide valid proxy)

Definition at line 653 of file SGImplSvc.cxx.

{
  return addAlias( aliasKey, proxy );
}

◆ setConst()

StatusCode SGImplSvc::setConst ( const void * pointer )

prevent downstream clients from modifying the pointed-at dobj

Definition at line 1209 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  // Check if DataProxy does not exist
  DataProxy * dp = proxy(pObject); 
 
  if (0 == dp)
    {
      SG_MSG_WARNING ("setConst: NO Proxy for the dobj you want to set const");
      return StatusCode::FAILURE;
    }
 
  dp->setConst();
  return StatusCode::SUCCESS;
}

◆ setProxyProviderSvc()

void SGImplSvc::setProxyProviderSvc ( IProxyProviderSvc * pPPSvc )

associate ProxyProviderSvc to this store

◆ setSlotNumber()

void SGImplSvc::setSlotNumber	(	int	slot,
		int	numSlots )

Set the Hive slot number for this store.

Parameters

slot	The slot number. -1 means that this isn't a Hive store.
numSlots	The total number of slots. Should be 1 for the non-Hive case.

Definition at line 897 of file SGImplSvc.cxx.

{
  m_slotNumber = slot;
  m_numSlots = numSlots;
 
  SG::ArenaHeader* header = SG::ArenaHeader::defaultHeader();
  header->setArenaForSlot (slot, &m_arena);
}

◆ setStoreID()

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

set store ID. request forwarded to DataStore:

set store id in DataStore:

Definition at line 474 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  store()->setStoreID(id);
}

◆ setupProxy()

DataProxy * SGImplSvc::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

Definition at line 432 of file SGImplSvc.cxx.

                                                 {
  // locate the proxy           
  DataProxy* dp = m_pStore->proxy_exact(dataID, gK);
  
  if (0 != dp) { //proxy found  
    if (0 != dp->object())
      {
        // Case 0: duplicated proxy               
        SG_MSG_WARNING (" setupProxy:: error setting up proxy for key {} and clid {}\n"
                        " Pre-existing valid DataProxy @{} found in Store for key {} with clid {}",
                        gK, dataID,
                        static_cast<void*>(dp),
                        dp->object()->name(),
                        dp->object()->clID());
        recycle(pDObj);      // commit this object to trash
        dp = 0;
      } else {
      // Case 1: Proxy found... if not valid, update it:
      dp->setObject(pDObj);
      if (!allowMods) dp->setConst();
    } 
  } else {
    // Case 2: No Proxy found:
    dp = new DataProxy(pDObj,
                       TransientAddress(dataID, gK),
                       !allowMods, resetOnly);
    if (!(m_pStore->addToStore(dataID, dp).isSuccess())) {
      SG_MSG_WARNING (" setupProxy:: could not addToStore proxy @{}",
                      static_cast<void*>(dp));
      recycle(pDObj);      // commit this object to trash
      delete dp;
      dp = 0;
    }
  }
  return dp;
}

◆ sourceID()

SG::SourceID SGImplSvc::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.

Returns an empty string if no source has been set.

The default version always returns an empty string.

Definition at line 1667 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  SG::DataProxy* dp =proxy (ClassID_traits<DataHeader>::ID(), key, true);
  if (dp) {
    const DataHeader* dh = SG::DataProxy_cast<DataHeader> (dp);
    if (dh) {
      return dh->begin()->getToken()->dbID().toString();
    }
  }
  return "";
}

◆ start()

StatusCode SGImplSvc::start ( )

finaloverridevirtual

Service start.

Definition at line 200 of file SGImplSvc.cxx.

                               {
 
  SG_MSG_VERBOSE ("Start {}", name());
  /*
  // This will need regFcn clients to be updated first.
  if ( 0 == m_pPPS || (m_pPPS->preLoadProxies(*m_pStore)).isFailure() ) {
     SG_MSG_DEBUG (" Failed to preLoad proxies");
     return StatusCode::FAILURE;
  }
  */
 
  return StatusCode::SUCCESS;
}

◆ stop()

StatusCode SGImplSvc::stop ( )

finaloverridevirtual

Service stop.

Definition at line 214 of file SGImplSvc.cxx.

                              {
 
  SG_MSG_VERBOSE ("Stop {}", name());
  //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 (store()->storeID() == StoreID::EVENT_STORE) {
    ISvcManager* pISM(dynamic_cast<ISvcManager*>(serviceLocator().get()));
    if (!pISM)
      return StatusCode::FAILURE;
    pISM->setPriority(name(), pISM->getPriority(name())+1).ignore();
    SG_MSG_VERBOSE ("stop: setting service priority to {} so that event stores get finalized and cleared before other stores",
                    pISM->getPriority(name()));
  }
  return StatusCode::SUCCESS;
}

◆ store() [1/2]

DataStore * SGImplSvc::store ( )

private

Definition at line 544 of file SGImplSvc.cxx.

{ 
  return m_pStore; 
}

◆ store() [2/2]

const DataStore * SGImplSvc::store ( ) const

private

Definition at line 550 of file SGImplSvc.cxx.

{ 
  return m_pStore; 
}

◆ storeID()

StoreID::type SGImplSvc::storeID ( ) const

overridevirtual

get store ID. request forwarded to DataStore:

get store id from DataStore:

Definition at line 480 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  return store()->storeID();
}

◆ stringToKey()

SGImplSvc::sgkey_t SGImplSvc::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 1298 of file SGImplSvc.cxx.

{
  lock_t lock (m_stringPoolMutex);
  return m_stringpool.stringToKey (str, clid);
}

◆ symLink() [1/2]

StatusCode SGImplSvc::symLink	(	const CLID	id,
		const std::string &	key,
		const CLID	linkid )

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

Definition at line 570 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  SG::DataProxy* dp(proxy(id, key, false));
  // if symLink already exists, just return success      
  return isSymLinked(linkID,dp) ?
    StatusCode::SUCCESS :
    addSymLink(linkID,dp);
}

◆ symLink() [2/2]

StatusCode SGImplSvc::symLink	(	const void *	p2BRegistered,
		CLID	linkID )

make a soft link to the object T* already registered

Definition at line 559 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  SG::DataProxy* dp(proxy(pObject));
 
  // if symLink already exists, just return success      
  return isSymLinked(linkID,dp) ?
    StatusCode::SUCCESS :
    addSymLink(linkID,dp);
}

◆ t2pRegister()

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

private

forwarded to DataStore

Definition at line 1189 of file SGImplSvc.cxx.

{ 
  return m_pStore->t2pRegister(pTrans, pPers);
}

◆ t2pRemove()

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

private

forwarded to DataStore

Definition at line 1196 of file SGImplSvc.cxx.

{
  m_pStore->t2pRemove(pTrans); 
}

◆ transientContains()

bool SGImplSvc::transientContains	(	const CLID	id,
		const std::string &	key ) const

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

returns false if object not available in TDS

Definition at line 687 of file SGImplSvc.cxx.

{
  try {
    return (0 != transientProxy(id, key));
  } catch(...) { return false; }
}

◆ transientProxy()

DataProxy * SGImplSvc::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 939 of file SGImplSvc.cxx.

{ 
  lock_t lock (m_mutex);
  DataProxy* dp(m_pStore->proxy(id, key));
  return ( (0 != dp && dp->isValidObject()) ? dp : 0 );
}

◆ transientSwap()

bool SGImplSvc::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 963 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  const bool checkValid = true;
  DataProxy* a = proxy( id, keyA, checkValid );
  DataProxy* b = proxy( id, keyB, checkValid );
  if ( 0 == a || 0 == b ) { return false; }
  DataObject* objA = a->accessData();
  DataObject* objB = b->accessData();
 
  if ( 0 == objA || 0 == objB ) { return false; }
  // prevent 'accidental' release of DataObjects...
  const unsigned int refCntA = objA->addRef(); 
  const unsigned int refCntB = objB->addRef();
  // in case swap is being specialized for DataObjects 
  using std::swap;
  swap( objA, objB );
  a->setObject( objA );
  b->setObject( objB );
  // and then restore old ref-count;
  return ( (refCntA-1) == objA->release() && 
           (refCntB-1) == objB->release() );
}

◆ tryELRemap()

bool SGImplSvc::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 1450 of file SGImplSvc.cxx.

{
  lock_t lock (m_remapMutex);
  SG::RemapImpl::remap_map_t::iterator i =
    m_remap_impl->m_remaps.find (sgkey_in);
  if (i == m_remap_impl->m_remaps.end())
    return false;
  const SG::RemapImpl::remap_t& payload = i->second;
  sgkey_out = payload.target;
  index_out = index_in + payload.index_offset;
  return true;
}

◆ typeCount()

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

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

Definition at line 670 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  return m_pStore->typeCount(id);
}  

◆ typeless_overwrite()

StatusCode SGImplSvc::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 1037 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  StatusCode sc(StatusCode::SUCCESS);
  SG::DataProxy* toRemove(proxy(clid, key, false));
  if (0 != toRemove) {
    toRemove->addRef();
    const bool FORCEREMOVE(true);        
    sc =removeProxy(toRemove, (void*)0, FORCEREMOVE);
  }
  if (sc.isSuccess()) {
    const bool ALLOWOVERWRITE(true);
    const bool NORESET(false);
    if (record_impl( obj, key, raw_ptr, allowMods, NORESET, ALLOWOVERWRITE, tinfo) == nullptr)
      sc = StatusCode::FAILURE;
    else if ( m_ActivateHistory && noHist && store()->storeID() == StoreID::EVENT_STORE ) {
      sc = record_HistObj( obj->clID(), key, name(), allowMods, NORESET );
    }
  }
  //for detector store objects managed by IIOVSvc, replace the old proxy with the new one (#104311)
  if (toRemove && sc.isSuccess() && store()->storeID() == StoreID::DETECTOR_STORE) {
    sc = m_pIOVSvc->replaceProxy(toRemove, proxy(clid, key));
  }
  if (toRemove)
    toRemove->release();
  return sc;
}

◆ typeless_record() [1/3]

StatusCode SGImplSvc::typeless_record	(	DataObject *	obj,
		const std::string &	key,
		const void *const	raw_ptr,
		bool	allowMods,
		bool	resetOnly,
		bool	noHist,
		const std::type_info *	tinfo )

private

Definition at line 999 of file SGImplSvc.cxx.

{
  return typeless_record (obj, key, raw_ptr, allowMods, resetOnly, noHist,tinfo,
                          nullptr, true);
}

◆ typeless_record() [2/3]

StatusCode SGImplSvc::typeless_record	(	DataObject *	obj,
		const std::string &	key,
		const void *const	raw_ptr,
		bool	allowMods,
		bool	resetOnly,
		bool	noHist,
		const std::type_info *	tinfo,
		SG::DataProxy **	proxy_ret,
		bool	noOverwrite )

private

Definition at line 1010 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  SG::DataProxy* proxy =
    record_impl( obj, key, raw_ptr, allowMods, resetOnly, !noOverwrite, tinfo);
  if ( proxy == nullptr )
    return StatusCode::FAILURE;
  if (proxy_ret)
    *proxy_ret = proxy;
 
  if ( !m_ActivateHistory || noHist ) {
    return StatusCode::SUCCESS;
  }
 
  if ( store()->storeID() != StoreID::EVENT_STORE ) {
    return StatusCode::SUCCESS;
  } else {
    return record_HistObj( obj->clID(), key, name(), allowMods, resetOnly );
  }
}

◆ typeless_record() [3/3]

StatusCode SGImplSvc::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 989 of file SGImplSvc.cxx.

{
  return typeless_record (obj, key, raw_ptr, allowMods, resetOnly, noHist, 0,
                          nullptr, true);
}

◆ typeless_retrievePrivateCopy()

DataObject * SGImplSvc::typeless_retrievePrivateCopy	(	const CLID	clid,
		const std::string &	key )

Definition at line 1465 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  DataObject* obj = nullptr;
  SG::DataProxy* dp = proxy (clid, key);
  //we do not want anyone to mess up with our copy hence we release it immediately.
  if (dp && dp->isValid()) {
    obj = dp->object();
    obj->addRef();
    clearProxyPayload (dp);
  }
  return obj;
}

◆ unboundHandle()

void SGImplSvc::unboundHandle ( IResetable * handle )

finaloverridevirtual

Tell the store that a handle has been unbound from a proxy.

Parameters

handle The handle that was unbound. The default implementation does nothing.

Definition at line 1604 of file SGImplSvc.cxx.

{
  std::vector<IResetable*>& v = m_newBoundHandles[std::this_thread::get_id()];
  std::vector<IResetable*>::iterator it =
    std::find (v.begin(), v.end(), handle);
  if (it != v.end())
    v.erase (it);
}

◆ ActiveStoreSvc

friend class ActiveStoreSvc

friend

Definition at line 634 of file SGImplSvc.h.

◆ 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

◆ IOVDbSvc

friend class IOVDbSvc

friend

access clearProxyPayload

Definition at line 567 of file SGImplSvc.h.

◆ IOVSvcTool

friend class IOVSvcTool

friend

Definition at line 568 of file SGImplSvc.h.

◆ SG::VarHandleBase

friend class SG::VarHandleBase

friend

access typeless_record

Definition at line 582 of file SGImplSvc.h.

◆ StoreGateSvc

friend class StoreGateSvc

friend

Definition at line 580 of file SGImplSvc.h.

Member Data Documentation

◆ m_ActivateHistory

bool SGImplSvc::m_ActivateHistory

private

Activate the history service.

Definition at line 655 of file SGImplSvc.h.

◆ m_arena

SG::Arena SGImplSvc::m_arena

private

Allocation arena to associate with this store.

Definition at line 671 of file SGImplSvc.h.

◆ m_DumpArena

bool SGImplSvc::m_DumpArena

private

DumpArena Property flag : trigger m_arena->report() at clearStore.

Definition at line 656 of file SGImplSvc.h.

◆ m_DumpStore

bool SGImplSvc::m_DumpStore

private

Dump Property flag: triggers dump() at EndEvent.

Definition at line 654 of file SGImplSvc.h.

◆ m_folderNameList

StringArrayProperty SGImplSvc::m_folderNameList

private

FolderNameList Property.

Definition at line 659 of file SGImplSvc.h.

◆ m_mutex

mutex_t SGImplSvc::m_mutex

mutableprivate

Definition at line 687 of file SGImplSvc.h.

◆ m_newBoundHandles

std::map<std::thread::id, std::vector<IResetable*> > SGImplSvc::m_newBoundHandles

private

Keep track of proxies bound since the last call to commitNewDataObjects or clearStore.

Has to be done per-thread. We can't use thread_specific_ptr because we want to be able to clear the vectors for all threads in clearStore().

Definition at line 683 of file SGImplSvc.h.

◆ m_numSlots

int SGImplSvc::m_numSlots

private

The total number of slots. 1 if this isn't a Hive store.

Definition at line 677 of file SGImplSvc.h.

◆ m_pCLIDSvc

ServiceHandle<IClassIDSvc> SGImplSvc::m_pCLIDSvc

private

Definition at line 640 of file SGImplSvc.h.

◆ m_pDataLoader

ServiceHandle<IConversionSvc> SGImplSvc::m_pDataLoader

private

Definition at line 641 of file SGImplSvc.h.

◆ m_pHistorySvc

ServiceHandle<IHistorySvc> SGImplSvc::m_pHistorySvc

private

Definition at line 648 of file SGImplSvc.h.

◆ m_pIncSvc

ServiceHandle<IIncidentSvc> SGImplSvc::m_pIncSvc

private

property

Definition at line 653 of file SGImplSvc.h.

◆ m_pIOVSvc

ServiceHandle<IIOVSvc> SGImplSvc::m_pIOVSvc

private

get the IOVSvc "just in time" (breaks recursion at initialize)

Definition at line 662 of file SGImplSvc.h.

◆ m_pPPS

IProxyProviderSvc* SGImplSvc::m_pPPS

private

Definition at line 646 of file SGImplSvc.h.

◆ m_pPPSHandle

ServiceHandle<IProxyProviderSvc> SGImplSvc::m_pPPSHandle

private

Definition at line 643 of file SGImplSvc.h.

◆ m_pStore

SG::DataStore* SGImplSvc::m_pStore

private

Definition at line 650 of file SGImplSvc.h.

◆ m_remap_impl

SG::RemapImpl* SGImplSvc::m_remap_impl

private

Definition at line 668 of file SGImplSvc.h.

◆ m_remapMutex

mutex_t SGImplSvc::m_remapMutex

mutableprivate

Definition at line 688 of file SGImplSvc.h.

◆ m_slotNumber

int SGImplSvc::m_slotNumber

private

The Hive slot number for this store, or -1 if this isn't a Hive store.

Definition at line 674 of file SGImplSvc.h.

◆ m_storeLoaded

bool SGImplSvc::m_storeLoaded

private

FIXME hack needed by loadEventProxies.

Definition at line 664 of file SGImplSvc.h.

◆ m_stringpool

SG::StringPool SGImplSvc::m_stringpool

private

Definition at line 666 of file SGImplSvc.h.

◆ m_stringPoolMutex

mutex_t SGImplSvc::m_stringPoolMutex

mutableprivate

Definition at line 689 of file SGImplSvc.h.

◆ m_trash

std::list<DataObject*> SGImplSvc::m_trash

private

The Recycle Bin.

Definition at line 651 of file SGImplSvc.h.

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

Public Member Functions

String <-> int key conversions. IStringPool implementation

IHiveStoreMgr implementation

Detailed Description

Member Typedef Documentation

◆ lock_t

◆ mutex_t

◆ sgkey_t

Constructor & Destructor Documentation

◆ SGImplSvc() [1/2]

◆ SGImplSvc() [2/2]

◆ ~SGImplSvc()

Member Function Documentation

◆ accessData() [1/2]

◆ accessData() [2/2]

◆ addAlias()

◆ addAutoSymLinks()

◆ addSymLink()

◆ addToStore()

◆ associateAux_impl() [1/2]

◆ associateAux_impl() [2/2]

◆ boundHandle()

◆ clearProxyPayload()

◆ clearStore()

◆ clid()

◆ clids() [1/2]

◆ clids() [2/2]

◆ commitNewDataObjects()

◆ contains()

◆ createKey()

◆ createObj()

◆ dump()

◆ emptyTrash()

◆ finalize()

◆ handle()

◆ hiveProxyDict()

◆ initialize()

◆ isSymLinked()

◆ keys()

◆ keyToString() [1/2]

◆ keyToString() [2/2]

◆ loadEventProxies()

◆ locatePersistent()

◆ makeCurrent()

◆ mergeStringPool()

◆ msg_update_handler()

◆ operator=()

◆ 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()

◆ record_HistObj()

◆ record_impl()

◆ recordAddress() [1/2]

◆ recordAddress() [2/2]

◆ recordObject()

◆ recycle()

◆ registerKey()

◆ reinitialize()

◆ releaseObject()

◆ remap_impl()

◆ remove()

◆ removeDataAndProxy()

◆ removeProxy()

◆ retrieve()

◆ setAlias() [1/3]

◆ setAlias() [2/3]

◆ setAlias() [3/3]

◆ setConst()

◆ setProxyProviderSvc()

◆ setSlotNumber()

◆ setStoreID()

◆ setupProxy()

◆ sourceID()