SG::DataStore Class Reference

Hold DataProxy instances associated with a store. More...

#include <DataStore.h>

Inheritance diagram for SG::DataStore:

Collaboration diagram for SG::DataStore:

Public Types
typedef IStringPool::sgkey_t	sgkey_t
typedef std::map< CLID, SG::ProxyMap >	StoreMap
typedef StoreMap::iterator	StoreIterator
typedef StoreMap::const_iterator	ConstStoreIterator
typedef std::pair< SG::ConstProxyIterator, SG::ConstProxyIterator >	constProxyRange

Public Member Functions
	DataStore (IProxyDict &pool)
	Constructor.
virtual	~DataStore ()
void	setStoreID (StoreID::type id)
virtual StoreID::type	storeID () const override
void	clearStore (bool force, bool hard, MsgStream *pmlog)
	If HARD is true, then the bound objects should also clear any data that depends on the identity of the current event store.

Implementation of IProxyRegistry.
using	KeyMap_t = ConcurrentSGKeyMap<DataProxy*>
	Map of hashed sgkey -> DataProxy.
IProxyDict &	m_pool
	The string pool associated with this store.
std::vector< DataProxy * >	m_proxies
	All proxies managed by this store.
StoreMap	m_storeMap
	Maps locating proxies by clid/key.
KeyMap_t	m_keyMap
StoreID::type	m_storeID
T2pMap	m_t2p
SmartIF< ISGAudSvc >	m_pSGAudSvc
bool	m_noAudSvc
ISvcLocator *	m_pSvcLoc
virtual StatusCode	addToStore (const CLID &id, DataProxy *proxy) override
	add proxy to store.
virtual DataProxy *	proxy (const TransientAddress *tAddr) const override
	return proxy for a given type/key pair if key is empty returns the default proxy (currently last registered)
virtual DataProxy *	proxy (const CLID &id, const std::string &key=SG::DEFAULTKEY) const override
	get proxy with given id. Returns 0 to flag failure
virtual SG::DataProxy *	proxy_exact (sgkey_t sgkey) const override
	get proxy with given key.
SG::DataProxy *	proxy_exact_unlocked (sgkey_t sgkey, std::recursive_mutex &mutex) const
	Like proxy_exact, but intended to be called without holding the store lock.
virtual SG::DataProxy *	proxy_exact (const CLID &id, const std::string &key) const override
	get proxy with given id.
StatusCode	removeProxy (DataProxy *proxy, bool forceRemove, bool hard)
	remove proxy from store, unless proxy is reset only.
StatusCode	addSymLink (const CLID &linkid, DataProxy *proxy)
	add symlink to store:
virtual StatusCode	addAlias (const std::string &aliasKey, DataProxy *proxy) override
	add alias to store
int	typeCount (const CLID &id) const
	Count number of object of a given type in store.
StatusCode	tRange (ConstStoreIterator &f, ConstStoreIterator &e) const
	Return an iterator over the StoreMap:
StatusCode	pRange (const CLID &id, SG::ConstProxyIterator &f, SG::ConstProxyIterator &e) const
	Return an iterator over proxy for a given CLID:
void	setPac (IPageAccessControlSvc *pac)
	set IPageAccessControlSvc ptr in T2PMap
std::vector< const DataProxy * >	pacReport () const
	request an access control report, i.e. a list of proxies that have not been accessed since monitored
StatusCode	t2pRegister (const void *const pTrans, DataProxy *const pPers)
	methods to query the T2PMap:
void	t2pRemove (const void *const pTrans)
DataProxy *	locatePersistent (const void *const pTransient) const
	locate the persistent (proxy) for a given T* (void*):
void	keys (const CLID &id, std::vector< std::string > &vkeys, bool includeAlias, bool onlyValid)
const std::vector< DataProxy * > &	proxies () const
	All proxies managed by this store.
void	setSGAudSvc ()
bool	doAudit ()
StatusCode	setSvcLoc ()
StatusCode	removeFromKeyMap (DataProxy *proxy)
	Look for (and convert) a matching dummy proxy.
StatusCode	removeProxyImpl (DataProxy *proxy, int index)
	Helper for removing a proxy.

Detailed Description

Hold DataProxy instances associated with a store.

We hold proxies in several ways, for efficiency.

First, all proxies that we manage are entered in the m_proxies vector. A given proxy appears only once in this list.

Second, m_keyMap stores proxies indexed by the hashed CLID/key. A proxy may be entered here multiple times in the case of symlinks or alias; however, the entry corresponding to what proxy->sgkey() returns is called the `primary' entry.

Third, proxies are stored by CLID/key in m_storeMap. This is a map indexed by CLID; the values are maps indexed by key. A proxy may again be stored several times in this map in the case of symlinks/aliases.

A proxy may be given to the store that has the hashed key set, but not the CLID/key. This is referred to as a `dummy' proxy. This can happen when we read a link to an object that's not described in the event's DataHeader. In this case, the proxy is entered in m_proxies and m_keyMap, but not in m_storeMap. If we later look for a proxy by CLID/key and don't find it, we also look in m_keyMap to see if a dummy proxy has been entered there. If so, that point we fill in the CLID/key fields of the proxy and also enter it in m_storeMap.

Definition at line 73 of file Control/SGTools/SGTools/DataStore.h.

Member Typedef Documentation

constProxyRange

typedef std::pair<SG::ConstProxyIterator, SG::ConstProxyIterator> SG::DataStore::constProxyRange

Definition at line 83 of file Control/SGTools/SGTools/DataStore.h.

ConstStoreIterator

typedef StoreMap::const_iterator SG::DataStore::ConstStoreIterator

Definition at line 81 of file Control/SGTools/SGTools/DataStore.h.

KeyMap_t

using SG::DataStore::KeyMap_t = ConcurrentSGKeyMap<DataProxy*>

private

Map of hashed sgkey -> DataProxy.

Definition at line 186 of file Control/SGTools/SGTools/DataStore.h.

sgkey_t

typedef IStringPool::sgkey_t SG::DataStore::sgkey_t

Definition at line 78 of file Control/SGTools/SGTools/DataStore.h.

StoreIterator

typedef StoreMap::iterator SG::DataStore::StoreIterator

Definition at line 80 of file Control/SGTools/SGTools/DataStore.h.

StoreMap

typedef std::map<CLID, SG::ProxyMap> SG::DataStore::StoreMap

Definition at line 79 of file Control/SGTools/SGTools/DataStore.h.

Constructor & Destructor Documentation

DataStore()

DataStore::DataStore

(

IProxyDict &

pool

)

Constructor.

Parameters

pool	The string pool associated with this store.

Definition at line 29 of file Control/SGTools/src/DataStore.cxx.

  : m_pool (pool),
    m_storeMap(),
    m_keyMap(KeyMap_t::Updater_t()),
    m_storeID(StoreID::UNKNOWN), m_t2p(), 
    m_noAudSvc(0), m_pSvcLoc(0)
{
   setSvcLoc().ignore();
}

~DataStore()

DataStore::~DataStore ( )

virtual

Definition at line 40 of file Control/SGTools/src/DataStore.cxx.

{
  clearStore(false, true, nullptr);
}

Member Function Documentation

addAlias()

StatusCode DataStore::addAlias ( const std::string & aliasKey, DataProxy * proxy )

overridevirtual

add alias to store

Implements IProxyRegistry.

Definition at line 377 of file Control/SGTools/src/DataStore.cxx.

{
  for (CLID clid : dp->transientID()) {
    // locate proxy map and add alias to proxymap
    ProxyMap& pmap = m_storeMap[clid];
 
    // check if another proxy for the same type caries the same alias.
    // if yes, then remove that alias from that proxy and establish the
    // alias in the new proxy.
    // pmap.insert will overwrite, associate alias with new proxy.
    ConstProxyIterator p_iter = pmap.find(aliasKey);
    if (p_iter != pmap.end() && dp->clID() == p_iter->second->clID()) {
      if (dp->name() == p_iter->second->name()) return StatusCode::SUCCESS;
      p_iter->second->removeAlias(aliasKey);
      p_iter->second->release();
    }
    dp->addRef();
    pmap[aliasKey] = dp;
    m_keyMap.emplace (m_pool.stringToKey (aliasKey, clid), dp);
  }
 
  // set alias in proxy
  dp->setAlias(aliasKey);
 
  return StatusCode::SUCCESS;
}

addSymLink()

StatusCode DataStore::addSymLink	(	const CLID &	linkid,
		DataProxy *	proxy )

add symlink to store:

Definition at line 330 of file Control/SGTools/src/DataStore.cxx.

{
  // Make sure the symlink doesn't already exist.
  DataProxy* exist = proxy_exact (linkid, dp->name());
  if (exist == dp) {
    // Entry already exists pointing at the desired proxy.
    return StatusCode::SUCCESS;
  }
  else if (!exist) {
    dp->setTransientID(linkid); 
    return addToStore(linkid, dp);
  }
 
  // Already an existing proxy.
  if (exist->isValidObject()) {
    // And it's set to something.  Ok if it's the same DataObject.
    // Otherwise fail.
    if (exist->object() == dp->object()) {
      dp->setTransientID(linkid); 
      return StatusCode::SUCCESS;
    }
    return StatusCode::FAILURE;
  }
  if (!dp->object()) {
    return StatusCode::FAILURE;
  }
  if (exist->loader()) {
    return StatusCode::FAILURE;
  }
 
  // The existing proxy is not set to anything, and it doesn't have a loader.
  // It may have been created by a forward-declared link to a base class.
  // In that case, set the existing proxy to also point at the same DataObject.
  const SG::BaseInfoBase* bib = SG::BaseInfoBase::find (dp->clID());
  if (bib && bib->is_base (exist->clID())) {
    dp->setTransientID(linkid);
    exist->setObject (dp->object(), false);
    return StatusCode::SUCCESS;
  }
    
  // Entry already exists pointing at another proxy.
  // Don't change the existing entry.
  return StatusCode::FAILURE;
}

addToStore()

StatusCode DataStore::addToStore ( const CLID & id, DataProxy * proxy )

overridevirtual

add proxy to store.

If this proxy has not yet been added to the store, then make an entry for it in m_proxies.

Implements IProxyRegistry.

Definition at line 140 of file Control/SGTools/src/DataStore.cxx.

{
  if (!dp) {
    return StatusCode::FAILURE;
  }

  bool primary = false;
  if (dp->store() == nullptr) {
    m_proxies.push_back (dp);
    primary = true;
  }
 
  if (id == 0 && dp->clID() == 0 && dp->sgkey() != 0) {
    // Handle a dummied proxy.
    m_keyMap.emplace (dp->sgkey(), dp);
  }
  else {
    ProxyMap& pmap = m_storeMap[id];
 
    // Set the primary key.
    sgkey_t primary_sgkey = m_pool.stringToKey (dp->name(), dp->clID());
    sgkey_t sgkey = primary_sgkey;
    if (id != dp->clID()) {
      sgkey = m_pool.stringToKey (dp->name(), id);
    }
    if (dp->sgkey() == 0) {
      dp->setSGKey (sgkey);
    }
 
    if (!m_keyMap.emplace (sgkey, dp).second) {
      if (primary) {
        m_proxies.pop_back();
      }
      return StatusCode::FAILURE;
    }
 
    pmap.insert(ProxyMap::value_type(dp->name(), dp));
  }
 
  // Note : No checking if proxy already exists in store because it
  // is already checked in StoreGateSvc.  
  //  if (pmap.find(dp->name()) == pmap.end()) {
  dp->addRef();   // The store now owns this
  dp->setT2p(&m_t2p);
  dp->setStore(&m_pool);
 
  return StatusCode::SUCCESS;
}

clearStore()

void DataStore::clearStore	(	bool	force,
		bool	hard,
		MsgStream *	pmlog )

If HARD is true, then the bound objects should also clear any data that depends on the identity of the current event store.

(See IResetable.h.)

Be careful with changing this — it's important for performance for some analysis use cases.

Rather than dealing with erasures in m_keyMap, we first do the removals just from m_storeMap, remembering along the way the set of proxies to be removed (not reset-ony). Then if there were any such proxies, we run through the entries in m_keyMap and copy all that match one of the reset-only proxies to a new map and then swap. (We can't ask the proxy itself if it's reset-only at this point because if it isn't, it'll have been deleted.)

Go through the list of unique proxies, and run requestRelease() on each. If that returns true, then we're meant to remove this proxy from the store. Be careful that removing a proxy from the store will modify the m_proxies list, so if the proxy is successfully removed, we should not bump the index.

Definition at line 66 of file Control/SGTools/src/DataStore.cxx.

{

  std::unordered_set<DataProxy*> removed;
  
  for (size_t i = 0; i < m_proxies.size(); ) {
    SG::DataProxy* dp = m_proxies[i];
    if (dp->requestRelease (force, hard)) [[unlikely]] {
      removed.insert (dp);
      if (removeProxyImpl (dp, i).isFailure()) {
        ++i;
      }
    }
    else {
      ++i;
    }
  }
 
  if (!removed.empty()) {
    KeyMap_t newMap (KeyMap_t::Updater_t(), m_keyMap.capacity());
    {
      auto lock = newMap.lock();
      auto ctx = KeyMap_t::Updater_t::defaultContext();
      for (auto p : m_keyMap) {
        if (removed.count (p.second) == 0) {
          newMap.emplace (lock, p.first, p.second, ctx);
        }
      }
    }
    m_keyMap.swap (newMap);
  }
 
  // clear T2PMap
  m_t2p.clear();
}

doAudit()

bool SG::DataStore::doAudit ( )

inlineprivate

Definition at line 199 of file Control/SGTools/SGTools/DataStore.h.

                          {
      if (!m_noAudSvc) setSGAudSvc();
      return (m_pSGAudSvc);
    }

keys()

void DataStore::keys	(	const CLID &	id,
		std::vector< std::string > &	vkeys,
		bool	includeAlias,
		bool	onlyValid )

Definition at line 119 of file Control/SGTools/src/DataStore.cxx.

{
  vkeys.clear();
  for (const ProxyMap::value_type& p : m_storeMap[id]) {
    bool includeProxy(true);
    if (onlyValid) includeProxy=p.second->isValid();
    if (includeAlias) {
      if (includeProxy) vkeys.push_back(p.first);
    }
    else {
      if (p.first == p.second->name() && includeProxy) 
    vkeys.push_back(p.first);
    }
  }
}

locatePersistent()

DataProxy * SG::DataStore::locatePersistent

(

const void *const

pTransient

)

const

locate the persistent (proxy) for a given T* (void*):

pacReport()

std::vector< const DataProxy * > SG::DataStore::pacReport ( ) const

inline

request an access control report, i.e. a list of proxies that have not been accessed since monitored

Definition at line 156 of file Control/SGTools/SGTools/DataStore.h.

{ return m_t2p.pacReport();}

pRange()

StatusCode SG::DataStore::pRange	(	const CLID &	id,
		SG::ConstProxyIterator &	f,
		SG::ConstProxyIterator &	e ) const

Return an iterator over proxy for a given CLID:

proxies()

const std::vector< DataProxy * > & SG::DataStore::proxies

(

)

const

All proxies managed by this store.

Every proxy appears exactly once in this list.

proxy() [1/2]

DataProxy * DataStore::proxy ( const CLID & id, const std::string & key = SG::DEFAULTKEY ) const

overridevirtual

get proxy with given id. Returns 0 to flag failure

Implements IProxyRegistry.

Definition at line 420 of file Control/SGTools/src/DataStore.cxx.

{    
 
  // The logic here: if a key is specified, we locate it.
  // If we don't find it and the default key (DEFAULTKEY) is specified,
  // then we return any existing proxy for this type as long as there
  // is exactly one, not counting aliases.  More than one would be ambiguous
      
  ConstStoreIterator siter = m_storeMap.find(id);
  DataProxy *p(0);
  if (siter != m_storeMap.end()) 
  {
    const ProxyMap& pmap = siter->second;
    ConstProxyIterator p_iter = pmap.find(key);
    if (p_iter != pmap.end()) {
      p=p_iter->second;
 
    } else if (key == SG::DEFAULTKEY && !pmap.empty()) {
      // we did not find the object using key.
      // Now check for default object.
      // If there are multiple entries, they must all be
      // referring to the same proxy (aliases).
      for (const auto& ent : pmap) {
        if (!p) {
          p = ent.second;
        }
        else if (p != ent.second) {
          p = nullptr;
          break;
        }
      }
 
      // If that didn't work, try it again, considering only objects that
      // are exactly the type being requested.
      if (!p) {
        for (const auto& ent : pmap) {
          if (ent.second->clID() == id) {
            if (!p) {
              p = ent.second;
            }
            else if (p != ent.second) {
              p = nullptr;
              break;
            }
          }
        }
      }
    }
    else {
      // Ok since access to DataStore is serialized by StoreGate.
      DataStore* nc_store ATLAS_THREAD_SAFE = const_cast<DataStore*> (this);
      p = nc_store->findDummy (id, key);
    }
  }
  else {
    // Ok since access to DataStore is serialized by StoreGate.
    DataStore* nc_store ATLAS_THREAD_SAFE = const_cast<DataStore*> (this);
    p = nc_store->findDummy (id, key);
  }
 
  if (p && m_pSGAudSvc) 
    m_pSGAudSvc->SGAudit(p->name(), id, 0, m_storeID);
 
  return p;
}

proxy() [2/2]

DataProxy * DataStore::proxy ( const TransientAddress * tAddr ) const

overridevirtual

return proxy for a given type/key pair if key is empty returns the default proxy (currently last registered)

Implements IProxyRegistry.

Definition at line 414 of file Control/SGTools/src/DataStore.cxx.

{
  return proxy(tAddr->clID(), tAddr->name());
}

proxy_exact() [1/2]

virtual SG::DataProxy * SG::DataStore::proxy_exact ( const CLID & id, const std::string & key ) const

overridevirtual

get proxy with given id.

Returns 0 to flag failure the key must match exactly (no wild carding for the default key)

Implements IProxyRegistry.

proxy_exact() [2/2]

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

overridevirtual

get proxy with given key.

Returns 0 to flag failure the key must match exactly (no wild carding for the default key)

Implements IProxyRegistry.

proxy_exact_unlocked()

SG::DataProxy * SG::DataStore::proxy_exact_unlocked	(	sgkey_t	sgkey,
		std::recursive_mutex &	mutex ) const

Like proxy_exact, but intended to be called without holding the store lock.

However, the store lock still must be passed as an argument; it will be acquired should be need to call the auditor service.

removeFromKeyMap()

StatusCode DataStore::removeFromKeyMap ( DataProxy * proxy )

private

Look for (and convert) a matching dummy proxy.

Remove a proxy from m_keyMap.

Parameters

id	The CLID for which to search.
key	The key for which to search.

In some cases, we may enter into the store a `dummy' proxy, which is identified only by the hashed CLID/key pair. (This can happen when we have a link to an object that's not listed in the DataHeader; in this case, we know the only hashed key and not the CLID or key.)

This function is called after we fail to find a proxy by CLID/key. It additionally checks to see if there exists a dummy proxy with a hash matching this CLID/key. If so, the CLID/key are filled in in the proxy, and the proxy is entered in m_storeMap.

Returns either the matching proxy or 0. */ DataProxy* findDummy (CLID id, const std::string& key);

/**

Remove a proxy from m_keyMap.

Parameters

proxy	The proxy being removed.
proxy	The proxy being removed.

Definition at line 235 of file Control/SGTools/src/DataStore.cxx.

{
  SG::DataProxy::AliasCont_t alias_set = proxy->alias();
  std::string name = proxy->name();
 
  for (CLID symclid : proxy->transientID()) 
  {
    sgkey_t sgkey = m_pool.stringToKey (name, symclid);
    m_keyMap.erase (sgkey);
 
    for (const std::string& alias : alias_set) {
      m_keyMap.erase (m_pool.stringToKey (alias, symclid));
    }
  }
 
  return StatusCode::SUCCESS;
}

removeProxy()

StatusCode DataStore::removeProxy	(	DataProxy *	proxy,
		bool	forceRemove,
		bool	hard )

remove proxy from store, unless proxy is reset only.

Parameters

forceRemove

remove the proxy no matter what If HARD is true, then the bound objects should also clear any data that depends on the identity of the current event store. (See IResetable.h.)

Definition at line 197 of file Control/SGTools/src/DataStore.cxx.

{
  if (!proxy) {
    return StatusCode::FAILURE;
  }
  
  if (!forceRemove && proxy->isResetOnly()) {
    // A reset-only proxy.  Don't remove it.
    proxy->reset (hard);
    return StatusCode::SUCCESS;
  }
 
  // First remove from m_keyMap.
  // We may fail to find the entry if this is a key that has been versioned.
  // E.g., we add aVersObj.  Call this DP1.
  // Then we add a new version of it.  Call this DP2.
  // The version logic will add the alias ';00;aVersObj' to DP1.
  // It will also then add the alias `aVersObj' to DP2.
  // This will overwrite the entries for DP1 in pmap and m_keyMap.
  // If we then clear and DP2 is removed first, then the m_keyMap entry
  // for DP1's primary key will be gone.
  // FIXME: Should just remove the versioned key code ... it's anyway
  // not compatible with MT.
  removeFromKeyMap (proxy).ignore();
 
  // Then remove from the m_storeMap and release the proxy.
  auto it = std::find (m_proxies.begin(), m_proxies.end(), proxy);
  if (it == m_proxies.end()) {
    return StatusCode::FAILURE;
  }
  return removeProxyImpl (proxy, it - m_proxies.begin());
}

removeProxyImpl()

StatusCode DataStore::removeProxyImpl ( DataProxy * proxy, int index )

private

Helper for removing a proxy.

Parameters

proxy	The proxy being removed.
index	The index of this proxy in m_proxies.

This removes the proxy from m_storeMap and releases it, but does NOT remove it from m_keyMap.

Definition at line 263 of file Control/SGTools/src/DataStore.cxx.

{
  proxy->setStore (nullptr);
    
  std::string name = proxy->name();
  CLID clid = proxy->clID();
  SG::DataProxy::AliasCont_t alias_set = proxy->alias();
 
  // nb. This has to be here, not just before the loop below,
  //     as the proxy may be deleted in the meantime.
  SG::DataProxy::CLIDCont_t clids = proxy->transientID();
 
  StoreIterator storeIter = m_storeMap.find(clid);
  if (storeIter != m_storeMap.end()) {
    ProxyMap& pmap = storeIter->second;
 
    // first remove the alias key:
    for (const std::string& alias : alias_set) {
      if (1 == pmap.erase(alias)) proxy->release();
    }
      
    // Remove primary entry.
    if (1 == pmap.erase(name)) {
      proxy->release();
    }
  }
  else {
    // A dummy proxy.
    proxy->release();
  }
 
  // Remove all symlinks too.
  for (CLID symclid : clids) 
  {
    if (clid == symclid) continue;
    storeIter = m_storeMap.find(symclid);
    if (storeIter != m_storeMap.end()) {
      ProxyMap& pmap = storeIter->second;
      SG::ProxyIterator it = pmap.find (name);
      if (it != pmap.end() && it->second == proxy) {
        storeIter->second.erase (it);
        proxy->release();
      }
        
      for (const std::string& alias : alias_set) {
        if (1 == pmap.erase (alias)) proxy->release();
      }
    }
  } //symlinks loop
 
  if (index != -1 && !m_proxies.empty()) {
    // Remove the proxy from m_proxies.  If it's not at the end, then
    // move the proxy at the end to this proxy's index (and update the
    // index for the other proxy stored in m_keyMap).
    if (index != (int)m_proxies.size() - 1) {
      m_proxies[index] = m_proxies.back();
    }
    m_proxies.pop_back();
  }
 
  return StatusCode::SUCCESS;
}

setPac()

void SG::DataStore::setPac ( IPageAccessControlSvc * pac )

inline

set IPageAccessControlSvc ptr in T2PMap

Definition at line 154 of file Control/SGTools/SGTools/DataStore.h.

{ m_t2p.setPac(pac); }

setSGAudSvc()

void DataStore::setSGAudSvc ( )

private

Definition at line 52 of file Control/SGTools/src/DataStore.cxx.

                            {
  if (!m_pSGAudSvc) {
    //try once to get the service
    if (!m_noAudSvc) {
      const bool DONOTCREATE(false);
      m_pSGAudSvc = m_pSvcLoc->service("SGAudSvc", DONOTCREATE);
      m_noAudSvc = not m_pSGAudSvc.isValid();
    }
  }
  return;
}

setStoreID()

void SG::DataStore::setStoreID ( StoreID::type id )

inline

Definition at line 92 of file Control/SGTools/SGTools/DataStore.h.

{ m_storeID = id;}

setSvcLoc()

StatusCode DataStore::setSvcLoc ( )

private

Definition at line 45 of file Control/SGTools/src/DataStore.cxx.

                               {
  StatusCode sc(StatusCode::FAILURE);
  m_pSvcLoc = Gaudi::svcLocator( );
  if (!m_pSvcLoc) std::cout<<"DataStore::setSvcLoc: WARNING svcLocator not found! "<<std::endl;
  return sc;
}

storeID()

virtual StoreID::type SG::DataStore::storeID ( ) const

inlineoverridevirtual

Implements IProxyRegistry.

Definition at line 93 of file Control/SGTools/SGTools/DataStore.h.

{ return m_storeID; }

t2pRegister()

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

methods to query the T2PMap:

t2pRemove()

void SG::DataStore::t2pRemove ( const void *const pTrans )

inline

Definition at line 249 of file Control/SGTools/SGTools/DataStore.h.

  {
    m_t2p.t2pRemove(pTrans);
  }

tRange()

StatusCode SG::DataStore::tRange	(	ConstStoreIterator &	f,
		ConstStoreIterator &	e ) const

Return an iterator over the StoreMap:

typeCount()

int DataStore::typeCount

(

const CLID &

id

)

const

Count number of object of a given type in store.

Definition at line 405 of file Control/SGTools/src/DataStore.cxx.

{
  ConstStoreIterator storeIter = m_storeMap.find(id);
  if (storeIter == m_storeMap.end()) return 0;
  return (storeIter->second).size();
}

Member Data Documentation

m_keyMap

KeyMap_t SG::DataStore::m_keyMap

private

Definition at line 187 of file Control/SGTools/SGTools/DataStore.h.

m_noAudSvc

bool SG::DataStore::m_noAudSvc

private

Definition at line 198 of file Control/SGTools/SGTools/DataStore.h.

m_pool

IProxyDict& SG::DataStore::m_pool

private

The string pool associated with this store.

Definition at line 176 of file Control/SGTools/SGTools/DataStore.h.

m_proxies

std::vector<DataProxy*> SG::DataStore::m_proxies

private

All proxies managed by this store.

Every proxy appears exactly once in this list.

Definition at line 180 of file Control/SGTools/SGTools/DataStore.h.

m_pSGAudSvc

SmartIF<ISGAudSvc> SG::DataStore::m_pSGAudSvc

private

Definition at line 197 of file Control/SGTools/SGTools/DataStore.h.

m_pSvcLoc

ISvcLocator* SG::DataStore::m_pSvcLoc

private

Definition at line 204 of file Control/SGTools/SGTools/DataStore.h.

m_storeID

StoreID::type SG::DataStore::m_storeID

private

Definition at line 189 of file Control/SGTools/SGTools/DataStore.h.

m_storeMap

StoreMap SG::DataStore::m_storeMap

private

Maps locating proxies by clid/key.

Definition at line 183 of file Control/SGTools/SGTools/DataStore.h.

m_t2p

T2pMap SG::DataStore::m_t2p

private

Definition at line 194 of file Control/SGTools/SGTools/DataStore.h.

---

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

• Control/SGTools/SGTools/DataStore.h
• Control/SGTools/src/DataStore.cxx