SGImplSvc Class Reference

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)
	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.
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:
StoreID::type	storeID () const
	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
IOVSvc interface
StatusCode	regFcn (const CallBackID &c1, const CallBackID &c2, const IOVSvcCallBackFcn &fcn, bool trigger=false)
	register a callback function(2) with an already registered function(1)
StatusCode	regFcn (const std::string &toolName, const CallBackID &c2, const IOVSvcCallBackFcn &fcn, 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.
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
virtual SG::DataProxy *	proxy (const CLID &id, const char *key) const final
	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
	get default proxy with given id, optionally checking validity.
virtual SG::DataProxy *	proxy (const CLID &id, const std::string &key, bool checkValid) const
	get proxy with given id and key, optionally checking validity.
virtual 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	AthenaOutputStream
	access proxyRange()
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
StatusCode	proxyRange (const CLID &id, SG::ConstProxyIterator &beg, SG::ConstProxyIterator &end) const
	return a range to all proxies of a given CLID
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
bool	bindHandleToProxy (const CLID &id, const std::string &key, IResetable *ir, SG::DataProxy *&dp)
	name says it all
bool	bindHandleToProxyAndRegister (const CLID &id, const std::string &key, IResetable *ir, SG::DataProxy *&dp)
	Also do registration with IOVSvc.
bool	bindHandleToProxyAndRegister (const CLID &id, const std::string &key, IResetable *ir, SG::DataProxy *&dp, const CallBackID &c, const IOVSvcCallBackFcn &fcn, bool trigger)
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 106 of file SGImplSvc.h.

Member Typedef Documentation

lock_t

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

private

Definition at line 724 of file SGImplSvc.h.

mutex_t

typedef std::recursive_mutex SGImplSvc::mutex_t

private

Definition at line 723 of file SGImplSvc.h.

sgkey_t

typedef IStringPool::sgkey_t SGImplSvc::sgkey_t

Definition at line 354 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 102 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 137 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 974 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 982 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 682 of file SGImplSvc.cxx.

{
  if (0 == proxy) {
    warning() << "addAlias: no target DataProxy given, Cannot alias to a non-existing object" 
              << endmsg;
    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 1676 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 {
          warning() << "record_impl: Doing auto-symlinks for object with CLID "
                    << clid
                    << " and SG key " << key 
                    << ": Proxy already set for base CLID " << bases[i]
                    << "; not making auto-symlink." << endmsg;
        }
      }
    }
 
    // Handle copy conversions.
    {
      for (CLID copy_clid : bib->get_copy_conversions()) {
        if (m_pStore->addSymLink (copy_clid, dp).isFailure()) {
          warning() << "record_impl: Doing auto-symlinks for object with CLID "
                    << clid
                    << " and SG key " << key 
                    << ": Proxy already set for copy-conversion CLID "
                    << copy_clid
                    << "; not making auto-symlink." << endmsg;
        }
      }
    }
  }
  else {
    if (warn_nobib) {
      warning() << "record_impl: Could not find suitable SG::BaseInfoBase for CLID ["
                << clid << "] (" << key << ") !\t"
                << "No auto-symlink established !"
                << endmsg;
    }
  }
}

addSymLink()

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

private

Definition at line 602 of file SGImplSvc.cxx.

{ 
  if (0 == dp) {
    warning() << "addSymLink: no target DataProxy found. Sorry, can't link to a non-existing data object"
              << endmsg;
    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 796 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 1916 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 1881 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;
}

bindHandleToProxy()

bool SGImplSvc::bindHandleToProxy ( const CLID & id, const std::string & key, IResetable * ir, SG::DataProxy *& dp )

private

name says it all

Definition at line 1357 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
 
  dp = m_pStore->proxy (id, key);
  if (dp == nullptr && m_pPPS != nullptr) {
    dp = m_pPPS->retrieveProxy(id, key, *m_pStore);
  }
 
  if (0 == dp) return false;
 
  if (! dp->bindHandle(ir) ) {
    fatal() << "DataHandle at " << hex << ir << dec 
            << " already bound to DataProxy with key " << ir->key() 
            << ". Cannot bind to proxy " << dp->name() << " as well\n"
            << "        You have probably registered multiple callbacks via regFcn with the same DataHandle using different keys (DataProxies)\n"
            << endmsg;
    return false;
  }
    
  //already done in DataHandleBase::setState  dp->addRef();
 
#ifndef NDEBUG
  SG_MSG_DEBUG(" Bound handle " << MSG::hex << ir << " to proxy " 
               << dp << MSG::dec); 
#endif
  return true;
}

bindHandleToProxyAndRegister() [1/2]

bool SGImplSvc::bindHandleToProxyAndRegister ( const CLID & id, const std::string & key, IResetable * ir, SG::DataProxy *& dp )

private

Also do registration with IOVSvc.

Definition at line 1389 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  bool ret = bindHandleToProxy (id, key, ir, dp);
  if (ret) {
    StatusCode sc = m_pIOVSvc->regProxy(dp,key);
    if (sc.isFailure()) return false;
  }
  return true;
}

bindHandleToProxyAndRegister() [2/2]

bool SGImplSvc::bindHandleToProxyAndRegister ( const CLID & id, const std::string & key, IResetable * ir, SG::DataProxy *& dp, const CallBackID & c, const IOVSvcCallBackFcn & fcn, bool trigger )

private

Definition at line 1403 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  bool ret = bindHandleToProxy (id, key, ir, dp);
  if (ret) {
    StatusCode sc = m_pIOVSvc->regProxy(dp,key);
    if (sc.isFailure()) return false;
    sc = m_pIOVSvc->regFcn(dp,c,fcn,trigger);
    if (sc.isFailure()) return false;
  }
  return true;
}

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 1757 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 1563 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 268 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);
      info() << "Report for Arena: " << m_arena.name() << '\n'
             << s.str() << endmsg;
    }
  }
  {
    lock_t lock (m_mutex);
    emptyTrash();
    for (auto& p : m_newBoundHandles)
      p.second.clear();
    assert(m_pStore);
    debug() << "Clearing store with forceRemove="
            << forceRemove << endmsg;
    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 1642 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 945 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 1658 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 1739 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 702 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 262 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 1800 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 524 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 1346 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 303 of file SGImplSvc.cxx.

                                  {
  verbose() << "Finalizing " << name() << endmsg ;
  
  // 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");
      info() << '\n' << dump() << endl 
             << endmsg;
    }
  }
}

hiveProxyDict()

virtual::IProxyDict * SGImplSvc::hiveProxyDict ( )

inlinefinaloverride

implements IHiveStore interface for compat with Hive

Definition at line 228 of file SGImplSvc.h.

                                                     {
    return this;
  }

initialize()

StatusCode SGImplSvc::initialize ( )

finaloverridevirtual

Service initialization.

Definition at line 147 of file SGImplSvc.cxx.

                                    {
 
  verbose() << "Initializing " << name() << endmsg;
 
  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);
  }
  // set up the incident service:
  if (!(m_pIncSvc.retrieve()).isSuccess()) {
    error() << "Could not locate IncidentSvc "
            << endmsg;
    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 494 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 485 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 1471 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 1487 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 243 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 1227 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 1781 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 1529 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 1287 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 935 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

finalvirtual

get default proxy with given id.

Returns 0 to flag failure Deprecated for the event store.

Definition at line 729 of file SGImplSvc.cxx.

{ 
  return proxy(id, false);
}

proxy() [2/7]

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

virtual

get default proxy with given id, optionally checking validity.

Returns

0 to flag failure

Check if it is valid

Definition at line 735 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]

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

inlinefinalvirtual

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

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

proxy() [4/7]

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

inlinevirtual

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

  { 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 759 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

virtual

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

Returns

0 to flag failure

Definition at line 765 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 720 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 912 of file SGImplSvc.cxx.

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

proxyProviderSvc()

IProxyProviderSvc * SGImplSvc::proxyProviderSvc

(

)

Return current ProxyProviderSvc.

proxyRange()

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

                                                       {
  lock_t lock (m_mutex);
  return m_pStore->pRange(id,begin,end);
}

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

{
  CLID clid = pDObj->clID();
  std::string rawKey(key);
  bool isVKey(SG::VersionedKey::isVersionedKey(key));
  if (isVKey) {
    //FIXME VersionedKeys will need to be handled more efficiently
    SG::VersionedKey vk(rawKey);
    DataProxy *dp(proxy(clid, vk.key()));
    if (dp) {
      //proxies primary key
      const std::string& pTAName(dp->name());
      //original key as versioned
      SG::VersionedKey primaryVK(pTAName);
      
      //if the existing matching object has no version
      //create a versioned alias for the original unversioned key
      //so it will remain accessible
      if (!SG::VersionedKey::isVersionedKey(pTAName)) {
        if (!(this->addAlias(primaryVK.rawVersionKey(), dp)).isSuccess()) {
          warning() << "record_impl: Could not setup alias key " 
                    << primaryVK.rawVersionKey() 
                    << " for unversioned object " << pTAName
                    << endmsg;      
          return nullptr;
        }
      }
      if (vk.isAuto()) {
        //make a new versioned key incrementing the existing version
        SG::VersionedKey newVK(primaryVK.key(), primaryVK.version()+1);
        //FIXME this will fail in a confusing way if version+1 is in use
        //FIXME need a better error message below, probably looking at all
        //FIXME aliases
        rawKey = newVK.rawVersionKey();
      }
    }
  }
  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();
      warning() << "record_impl: you are recording an object with key "
                << rawKey << ", type "  << clidTypeName
                << " (CLID " << clid << ')' 
                << "\n There is already a persistent version of this object. Recording a duplicate may lead to unreproducible results and it is deprecated."
                << endmsg;
    }
  }
  //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();
    warning() << "record_impl: failed for key="<< rawKey << ", type "
              << clidTypeName
              << " (CLID " << clid << ')' 
              << "\n object @" << raw_ptr 
              << " already in store with key="<< dp->name()
              << ". Will not record a duplicate! "
              << endmsg;
    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();
    warning() << "record_impl: Problem setting up the proxy for object @"
              << raw_ptr 
              << "\n recorded with key " << rawKey 
              << " of type "  << clidTypeName
              << " (CLID " << clid << ") in DataObject @" << pDObj
              << endmsg;
 
    return nullptr;
  }
 
  // record in t2p:
  if ( !(this->t2pRegister( raw_ptr, dp )).isSuccess() ) {
    std::string clidTypeName; 
    m_pCLIDSvc->getTypeNameOfID(clid, clidTypeName).ignore();
    warning() << "record_impl: can not add to t2p map object @" <<raw_ptr 
              << "\n with key " << rawKey 
              << " of type "  << clidTypeName
              << " (CLID " << clid << ')' 
              << endmsg;
    return nullptr;
  }
 
  addAutoSymLinks (rawKey, clid, dp, tinfo);
 
  //handle versionedKeys: we register an alias with the "true" key
  //unless an object as already been recorded with that key.
  //Notice that addAlias overwrites any existing alias, so a generic
  //retrieve will always return the last version added 
  //FIXME not the one with the highest version
  if (isVKey) {
    SG::VersionedKey vk(rawKey);
    if (!(this->addAlias(vk.key(), dp)).isSuccess()) {
      warning() << "record_impl: Could not setup alias key " << vk.key() 
                << " for VersionedKey " << rawKey
                << ". Generic access to this object with clid" << clid 
                << " will not work"
                << endmsg;      
    }
  }
 
  return dp;
}

recordAddress() [1/2]

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

{
  lock_t lock (m_mutex);
  assert(0 != pAddress);
  CLID dataID = pAddress->clID();
 
  if (dataID == 0)
    {
      warning() << "recordAddress: Invalid Class ID found in IOpaqueAddress @" 
                << pAddress.get() << ". IOA will not be recorded"
                << endmsg;
      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();
      warning() << "recordAddress: failed for key="<< skey << ", type "
                << clidTypeName
                << " (CLID " << dataID << ')' 
                << "\n there is already a persistent version of this object. Will not record a duplicate! "
                << endmsg;
      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);
    }
  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();
      warning() << "recordAddress: preexisting proxy @" << dp
                << " with non-NULL IOA found for key " 
                << skey << " type " << errType << " (" << dataID << "). \n"
                << "Cannot record IOpaqueAddress @" << pAddress.get()
                << endmsg;
      return StatusCode::FAILURE;
    }
 
  return StatusCode::SUCCESS;
 
}    

recordAddress() [2/2]

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

Create a proxy object using an IOpaqueAddress.

Definition at line 414 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);
}    

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 823 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();
          warning() << "SGImplSvc::recordObject: addAlias fails for object "
                    << clid << "[" << clidTypeName << "] " << proxy->name()
                    << " and new key " << key
                    << endmsg;
          
          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();
          error() << "SGImplSvc::recordObject: addSymLink fails for object "
                  << clid << "[" << clidTypeName << "] " << proxy->name()
                  << " and new clid " << newclid << "[" << newclidTypeName << "]"
                  << endmsg;
          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();
        error() << "SGImplSvc::recordObject: existing object found with "
                << clid << "[" << clidTypeName << "] " << proxy->name()
                << " but neither clid " << newclid << "[" << newclidTypeName << "]"
                << " nor key " << key << " match."
                << endmsg;
        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 1339 of file SGImplSvc.cxx.

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

regFcn() [1/2]

StatusCode SGImplSvc::regFcn	(	const CallBackID &	c1,
		const CallBackID &	c2,
		const IOVSvcCallBackFcn &	fcn,
		bool	trigger = false )

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

Definition at line 501 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  return ( m_pIOVSvc->regFcn(c1,c2,fcn,trigger) );
}

regFcn() [2/2]

StatusCode SGImplSvc::regFcn	(	const std::string &	toolName,
		const CallBackID &	c2,
		const IOVSvcCallBackFcn &	fcn,
		bool	trigger = false )

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

Definition at line 512 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  return ( m_pIOVSvc->regFcn(toolName,c2,fcn,trigger) );
}

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 1506 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);
    REPORT_MESSAGE (MSG::WARNING) << "The numeric key " << key
                                  << " maps to multiple string key/CLID pairs: "
                                  << *str2 << "/" << clid2 << " and "
                                  << str << "/" << clid;
  }
}

reinitialize()

StatusCode SGImplSvc::reinitialize ( )

finaloverridevirtual

Service reinitialization.

Definition at line 324 of file SGImplSvc.cxx.

                                      {
  verbose() << "Reinitializing " << name() << endmsg ;
  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 1546 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 1591 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 1322 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 1331 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 1240 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 1850 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  SG::ConstProxyIterator first;
  SG::ConstProxyIterator end;
 
  if (!(proxyRange(clid,first,end)).isSuccess()) {
    std::string typnam;
    m_pCLIDSvc->getTypeNameOfID(clid, typnam).ignore();
    SG_MSG_DEBUG("retrieve(range): no object found " 
                 << " of type "  << typnam
                 << "(CLID " << 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 "  << typnam
                 << "(CLID " << 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 649 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 622 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
 
  SG::DataProxy* dp(0);
  dp = proxy(pObject);
  if (0 == dp) {
    error() << "setAlias: problem setting alias "
          << aliasKey << '\n'
          << "DataObject does not exist, record before setting alias."
          << endmsg;
    return StatusCode::FAILURE;
  }
 
  StatusCode sc = addAlias(aliasKey, dp);
  if (sc.isFailure()) {
    error() << "setAlias: problem setting alias " 
          << aliasKey << '\n'
          << "DataObject does not exist, record before setting alias."
          << endmsg;
    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 676 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 1302 of file SGImplSvc.cxx.

{
  lock_t lock (m_mutex);
  // Check if DataProxy does not exist
  DataProxy * dp = proxy(pObject); 
 
  if (0 == dp)
    {
      warning() << "setConst: NO Proxy for the dobj you want to set const"
                << endmsg;
      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 924 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 471 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 429 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               
        warning() << " setupProxy:: error setting up proxy for key " 
                  << gK << " and clid " << dataID
                  << "\n Pre-existing valid DataProxy @"<< dp 
                  << " found in Store for key " <<  dp->object()->name()
                  << " with clid " << dp->object()->clID()
                  << endmsg;
        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())) {
      warning() << " setupProxy:: could not addToStore proxy @" << dp
                << endmsg;
      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 1832 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 199 of file SGImplSvc.cxx.

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

stop()

StatusCode SGImplSvc::stop ( )

finaloverridevirtual

Service stop.

Definition at line 214 of file SGImplSvc.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 (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();
    verbose() << "stop: setting service priority to " << pISM->getPriority(name()) 
              << " so that event stores get finalized and cleared before other stores" <<endmsg;
  }
  return StatusCode::SUCCESS;
}

store() [1/2]

DataStore * SGImplSvc::store ( )

private

Definition at line 564 of file SGImplSvc.cxx.

{ 
  return m_pStore; 
}

store() [2/2]

const DataStore * SGImplSvc::store ( ) const

private

Definition at line 570 of file SGImplSvc.cxx.

{ 
  return m_pStore; 
}

storeID()

StoreID::type SGImplSvc::storeID

(

)

const

get store ID. request forwarded to DataStore:

get store id from DataStore:

Definition at line 477 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 1457 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 590 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 579 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 1274 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 1281 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 711 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 966 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 990 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 1611 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 694 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 1064 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 1026 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 1037 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 1016 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 1626 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 1769 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);
}

Friends And Related Symbol Documentation

ActiveStoreSvc

friend class ActiveStoreSvc

friend

Definition at line 672 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

AthenaOutputStream

friend class AthenaOutputStream

friend

access proxyRange()

Definition at line 599 of file SGImplSvc.h.

IOVDbSvc

friend class IOVDbSvc

friend

access clearProxyPayload

Definition at line 585 of file SGImplSvc.h.

IOVSvcTool

friend class IOVSvcTool

friend

Definition at line 586 of file SGImplSvc.h.

SG::VarHandleBase

friend class SG::VarHandleBase

friend

access typeless_record

Definition at line 607 of file SGImplSvc.h.

StoreGateSvc

friend class StoreGateSvc

friend

Definition at line 605 of file SGImplSvc.h.

Member Data Documentation

m_ActivateHistory

bool SGImplSvc::m_ActivateHistory

private

Activate the history service.

Definition at line 693 of file SGImplSvc.h.

m_arena

SG::Arena SGImplSvc::m_arena

private

Allocation arena to associate with this store.

Definition at line 709 of file SGImplSvc.h.

m_DumpArena

bool SGImplSvc::m_DumpArena

private

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

Definition at line 694 of file SGImplSvc.h.

m_DumpStore

bool SGImplSvc::m_DumpStore

private

Dump Property flag: triggers dump() at EndEvent.

Definition at line 692 of file SGImplSvc.h.

m_folderNameList

StringArrayProperty SGImplSvc::m_folderNameList

private

FolderNameList Property.

Definition at line 697 of file SGImplSvc.h.

m_mutex

mutex_t SGImplSvc::m_mutex

mutableprivate

Definition at line 725 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 721 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 715 of file SGImplSvc.h.

m_pCLIDSvc

ServiceHandle<IClassIDSvc> SGImplSvc::m_pCLIDSvc

private

Definition at line 678 of file SGImplSvc.h.

m_pDataLoader

ServiceHandle<IConversionSvc> SGImplSvc::m_pDataLoader

private

Definition at line 679 of file SGImplSvc.h.

m_pHistorySvc

ServiceHandle<IHistorySvc> SGImplSvc::m_pHistorySvc

private

Definition at line 686 of file SGImplSvc.h.

m_pIncSvc

ServiceHandle<IIncidentSvc> SGImplSvc::m_pIncSvc

private

property

Definition at line 691 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 700 of file SGImplSvc.h.

m_pPPS

IProxyProviderSvc* SGImplSvc::m_pPPS

private

Definition at line 684 of file SGImplSvc.h.

m_pPPSHandle

ServiceHandle<IProxyProviderSvc> SGImplSvc::m_pPPSHandle

private

Definition at line 681 of file SGImplSvc.h.

m_pStore

SG::DataStore* SGImplSvc::m_pStore

private

Definition at line 688 of file SGImplSvc.h.

m_remap_impl

SG::RemapImpl* SGImplSvc::m_remap_impl

private

Definition at line 706 of file SGImplSvc.h.

m_remapMutex

mutex_t SGImplSvc::m_remapMutex

mutableprivate

Definition at line 726 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 712 of file SGImplSvc.h.

m_storeLoaded

bool SGImplSvc::m_storeLoaded

private

FIXME hack needed by loadEventProxies.

Definition at line 702 of file SGImplSvc.h.

m_stringpool

SG::StringPool SGImplSvc::m_stringpool

private

Definition at line 704 of file SGImplSvc.h.

m_stringPoolMutex

mutex_t SGImplSvc::m_stringPoolMutex

mutableprivate

Definition at line 727 of file SGImplSvc.h.

m_trash

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

private

The Recycle Bin.

Definition at line 689 of file SGImplSvc.h.

---

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

• SGImplSvc.h
• SGImplSvc.cxx