Manage DataProxy reference in ElementLink/DataLink. More...

#include <DataProxyHolder.h>

Collaboration diagram for SG::DataProxyHolder:

Public Types
using	sgkey_t = SG::sgkey_t
	Type of hashed keys.
using	ID_type = std::string
	Type of string keys.
using	pointer_t = void*
	Generic pointer type.
using	const_pointer_t = const void*
typedef void *	castfn_t(SG::DataProxy *)
	Function casting from a `SG::DataProxy` to a pointer.

Public Member Functions
	DataProxyHolder ()
	Default constructor.
template<class FROM_STORABLE, class TO_STORABLE>
	DataProxyHolder (const DataProxyHolder &other, FROM_STORABLE , TO_STORABLE )
	Constructor from a holder referencing a different type.
	DataProxyHolder (const DataProxyHolder &)=default
DataProxyHolder &	operator= (const DataProxyHolder &)=default
void	clear ()
	Reset the link to null.
sgkey_t	toStorableObject (const_pointer_t obj, CLID link_clid, IProxyDict *sg)
	Set the link to an object given by a pointer.
sgkey_t	toIdentifiedObject (const ID_type &dataID, CLID link_clid, IProxyDict *sg)
	Set the link to an object given by a string key.
void	toIdentifiedObject (sgkey_t key, CLID link_clid, IProxyDict *sg)
	Set the link to an object given by a hashed key.
bool	isDefault () const
	Test to see if this is a null link.
const ID_type &	dataID () const
	Return the SG key that we reference, as a string.
void *	storableBase (castfn_t *castfn, CLID clid, bool isConst) const
	Return a pointer to the currently-referenced object.
SG::DataProxy *	proxy (bool nothrow=false) const
	Return the `DataProxy` for this link.
IProxyDict *	source () const
	Return the data source for this reference.
void	toTransient (sgkey_t sgkey, IProxyDict *sg=0)
	Finish initialization after link has been read.
sgkey_t	toTransient (const ID_type &dataID, CLID link_clid, IProxyDict *sg=0)
	Finish initialization after link has been read.
void	toPersistentNoRemap (sgkey_t &sgkey)
	Prepare this link for writing.
bool	toPersistent (sgkey_t &sgkey, uint64_t &index)
	Prepare this link for writing.
bool	toPersistent (sgkey_t &sgkey, uint32_t &index)
	Prepare this link for writing.
template<class T>
bool	toPersistent (sgkey_t &sgkey, const T &)
	Prepare this link for writing.
bool	operator== (const DataProxyHolder &other) const
	Compare for equality.
void	throwInvalidLink (sgkey_t sgkey) const
	Throw a `ExcInvalidLink` exception for this link.

Static Public Member Functions
static bool	thin (sgkey_t &sgkey, size_t &index, const SG::ThinningCache *thinningCache)
	Adjust for thinning, with explicitly provided thinning cache.
static void	resetCachedSource ()

Private Member Functions
bool	isObjpointer () const
	Test to see if we're pointing directly at an object.
pointer_t	objpointer () const
	Return a pointer to the object we're pointing at directly.
void	storeObjpointer (const_pointer_t p)
	Store a direct pointer to an object.
SG::DataProxy *	proxy1 (bool nothrow) const
	Helper for `proxy()`, for the case of a direct object pointer.
IProxyDict *	source1 ()
	Return the data source for this reference.
bool	tryRemap (sgkey_t &sgkey, size_t &index)
	Test to see if the link has been remapped.

Private Attributes
SG::DataProxy *	m_proxy
	The `DataProxy` referring to our object, if the LSB is clear; pointer to the object which we're referencing directly if the LSB is set.

Detailed Description

Manage DataProxy reference in ElementLink/DataLink.

This class factors out operations on DataProxy that are common between ElementLink and DataLink, and holds a pointer to the proxy. This pointer is transient; the (persistent) SG key field is stored in the class that holds this one, and is passed as a parameter where needed.

We can be initialized either with a key or with a pointer to an object. In the former case, we try immediately to look up the proxy for that key. If we find it, then we use it; otherwise, we create a dummy DataProxy for that key and add it to our store. If we're given a pointer, we again immediately try to look up the corresponding proxy. If we don't find it, then we store the pointer directly in the proxy member, with a flag to identify this case. Subsequent operations that require a proxy will again try to look up the proxy in the store; if that fails, then an exception will be thrown.

When we create a new link, the store by default is taken from the global default given by SG::CurrentEventStore::store(). This is a thread-specific value, so fetching it can be expensive. If you are creating links inside a loop, it is best to fetch the default before the loop and then passing the result explicitly when you create the links.

Definition at line 61 of file DataProxyHolder.h.

Member Typedef Documentation

◆ castfn_t

typedef void * SG::DataProxyHolder::castfn_t(SG::DataProxy *)

Function casting from a SG::DataProxy to a pointer.

Definition at line 75 of file DataProxyHolder.h.

◆ const_pointer_t

using SG::DataProxyHolder::const_pointer_t = const void*

Definition at line 72 of file DataProxyHolder.h.

◆ ID_type

using SG::DataProxyHolder::ID_type = std::string

Type of string keys.

Definition at line 68 of file DataProxyHolder.h.

◆ pointer_t

using SG::DataProxyHolder::pointer_t = void*

Generic pointer type.

Definition at line 71 of file DataProxyHolder.h.

◆ sgkey_t

using SG::DataProxyHolder::sgkey_t = SG::sgkey_t

Type of hashed keys.

Definition at line 65 of file DataProxyHolder.h.

Constructor & Destructor Documentation

◆ DataProxyHolder() [1/3]

SG::DataProxyHolder::DataProxyHolder ( )

Default constructor.

Make a null link.

◆ DataProxyHolder() [2/3]

template<class FROM_STORABLE, class TO_STORABLE>

SG::DataProxyHolder::DataProxyHolder	(	const DataProxyHolder &	other,
		FROM_STORABLE *	,
		TO_STORABLE *	)

Constructor from a holder referencing a different type.

Parameters

other The object from which to copy.

FROM_STORABLE is the storable class to which other refers; TO_STORABLE is the storable class for this object. The actual pointer values are not used, just the types are used. Default conversions for the storable pointer (i.e., derived->base) are allowed.

◆ DataProxyHolder() [3/3]

SG::DataProxyHolder::DataProxyHolder ( const DataProxyHolder & )

default

Member Function Documentation

◆ clear()

void SG::DataProxyHolder::clear ( )

Reset the link to null.

◆ dataID()

const DataProxyHolder::ID_type & SG::DataProxyHolder::dataID ( ) const

Return the SG key that we reference, as a string.

Returns a null string on failure.

Definition at line 229 of file DataProxyHolder.cxx.

{
  SG::DataProxy* dp = proxy (true);
  if (dp)
    return dp->name();
 
  static const std::string dummy;
  return dummy;
}

◆ isDefault()

bool SG::DataProxyHolder::isDefault ( ) const

Test to see if this is a null link.

◆ isObjpointer()

bool SG::DataProxyHolder::isObjpointer ( ) const

private

Test to see if we're pointing directly at an object.

Returns: True if we're pointing directly at an object, false if we're pointing at a DataProxy (or the link is null).

◆ objpointer()

pointer_t SG::DataProxyHolder::objpointer ( ) const

private

Return a pointer to the object we're pointing at directly.

Should be used only if isObjpointer() is true.

◆ operator=()

DataProxyHolder & SG::DataProxyHolder::operator= ( const DataProxyHolder & )

default

◆ operator==()

bool SG::DataProxyHolder::operator== ( const DataProxyHolder & other ) const

Compare for equality.

Definition at line 586 of file DataProxyHolder.cxx.

{
  if (m_proxy == other.m_proxy) return true;
 
  // One could refer to an object directly by pointer, the other could
  // have a proxy.
 
  const_pointer_t ptr = 0;
  const DataProxy* proxy = 0;
  if (isObjpointer() && !other.isObjpointer()) {
    ptr = objpointer();
    proxy = other.m_proxy;
  }
  else if (other.isObjpointer() && !isObjpointer()) {
    ptr = other.objpointer();
    proxy = m_proxy;
  }
  else
    return false;
 
  if (proxy->store()->proxy(ptr) == proxy)
    return true;
 
  return false;
}

◆ proxy()

SG::DataProxy * SG::DataProxyHolder::proxy ( bool nothrow = false ) const

Return the DataProxy for this link.

Parameters

nothrow If true, return 0 on failure instead of throwing an exception.

If this is a null link, we return 0. Otherwise, if we're pointing at a DataProxy, return it. Otherwise, we're pointing at an object directly. Try to look up the corresponding DataProxy using the default store. Return it if we find it; otherwise, either throw ExcPointerNotInSG or return 0, depending on the nothrow parameter.

◆ proxy1()

SG::DataProxy * SG::DataProxyHolder::proxy1 ( bool nothrow ) const

private

Helper for proxy(), for the case of a direct object pointer.

Parameters

nothrow If true, return 0 on failure instead of throwing an exception.

This is the out-of-line portion of proxy(), called if this link is directly pointing at an object. Try to look up the corresponding DataProxy using the default store. Return it if we find it; otherwise, either throw ExcPointerNotInSG or return 0, depending on the nothrow parameter.

Definition at line 571 of file DataProxyHolder.cxx.

{
  const_pointer_t obj = reinterpret_cast<const_pointer_t>
    (reinterpret_cast<unsigned long> (m_proxy) & ~1UL);
  SG::DataProxy* proxy = SG::CurrentEventStore::store()->proxy (obj);
  if (proxy == 0 && !nothrow)
    throw SG::ExcPointerNotInSG (obj);
  return proxy;
}

◆ resetCachedSource()

void SG::DataProxyHolder::resetCachedSource ( )

static

◆ source()

IProxyDict * SG::DataProxyHolder::source ( ) const

Return the data source for this reference.

If the link is null, return 0. If we're pointing at an object directly, then we return the default store if the object is found in SG; otherwise, throw ExcPointerNotInSG.

Definition at line 305 of file DataProxyHolder.cxx.

{
  SG::DataProxy* dp = proxy();
  if (!dp)
    return 0;
  return dp->store();
}

◆ source1()

IProxyDict * SG::DataProxyHolder::source1 ( )

private

Return the data source for this reference.

If we're holding a pointer directly, rather than a proxy, then return 0 rather than raising an exception.

Definition at line 630 of file DataProxyHolder.cxx.

{
  if (!m_proxy || isObjpointer()) {
    return 0;
  }
  return m_proxy->store();
}

◆ storableBase()

void * SG::DataProxyHolder::storableBase	(	castfn_t *	castfn,
		CLID	clid,
		bool	isConst ) const

Return a pointer to the currently-referenced object.

Parameters

castfn	Function to do the cast from data proxy to object. If 0, use a dynamic cast.
clid	The CLID of the desired object. This is used to determine how the returned pointer is to be converted.
isConst	True if the returned object will be treated as const.

Returns: A pointer to an object of the type given by clid, or null on a failure (or if the reference is null).

Definition at line 251 of file DataProxyHolder.cxx.

{
  // Test for null link.
  if (!m_proxy)
    return 0;
 
  // Test for direct pointer to an object.
  if (isObjpointer())
    return objpointer();
 
  // We have a proxy.  Check that we're not trying to use an object
  // that's been marked const in SG in a non-const way.
  if (!isConst && m_proxy->isConst()) {
    throw SG::ExcConstStorable (m_proxy->clID(),
                                m_proxy->name(),
                                m_proxy->sgkey());
  }
 
  // Ok --- DataProxy is thread-safe.
  SG::DataProxy* proxy_nc ATLAS_THREAD_SAFE = m_proxy;
 
  // Get the object pointer from the proxy.
  // We have to take care of converting to the proper return type, though
  // (as requested by clid).
  void* obj = castfn ? castfn (m_proxy) : SG::DataProxy_cast (proxy_nc, clid);
  if (obj)
    return obj;
 
  // We failed.  It may be that we don't have a conversion
  // between clid and the object type: it may have been stored
  // using a hard cast.  Check to see if this object has actually
  // been registered under the requested clid.
  if (m_proxy->transientID (clid)) {
    DataBucketBase* db =
      dynamic_cast<DataBucketBase*> (proxy_nc->accessData());
 
    // Do a hard cast...
    if (db)
      return db->object();
  }
 
  return 0;
}

◆ storeObjpointer()

void SG::DataProxyHolder::storeObjpointer ( const_pointer_t p )

private

Store a direct pointer to an object.

Parameters

p	Pointer to the object that we're referencing.

This will overwrite m_proxy with the reference to the object.

◆ thin()

bool SG::DataProxyHolder::thin	(	sgkey_t &	sgkey,
		size_t &	index,
		const SG::ThinningCache *	thinningCache )

static

Adjust for thinning, with explicitly provided thinning cache.

Adjust for thinning.

Parameters

sgkey	Reference to the hashed SG key.
index	Index of this link.
thinningCache	Thinning cache for the current stream (may be null).

If this link points to a container that has been thinned, sgkey and index will be adjusted accordingly.

Returns true if the index was changed; false otherwise.

Definition at line 507 of file DataProxyHolder.cxx.

{
  if (!sgkey) {
    return false;
  }
 
  // Check for thinning.
  if (thinningCache) {
    const SG::ThinningDecisionBase* dec = thinningCache->thinning (sgkey);
    if (dec) {
      // Get the updated index:
      const std::size_t persIdx = dec->index( index );
 
      // If the object was thinned away, set the persistent variables to an
      // invalid state. Otherwise update just the index variable.
      if( persIdx == ThinningDecisionBase::RemovedIdx ) {
        sgkey = 0;
        index = 0;
        return true;
      }
      else {
        if (index != persIdx) {
          index = persIdx;
          return true;
        }
      }
    }
  }
 
  return false;
}

◆ throwInvalidLink()

void SG::DataProxyHolder::throwInvalidLink ( sgkey_t sgkey ) const

Throw a ExcInvalidLink exception for this link.

Parameters

sgkey The hashed key for this link.

This will fill in parameters for the exception message from the proxy.

Definition at line 547 of file DataProxyHolder.cxx.

{
  CLID clid = CLID_NULL;
  std::string key;
  SG::DataProxy* dp = proxy();
  if (dp) {
    clid = dp->clID();
    key = dp->name();
  }
  throw SG::ExcInvalidLink (clid, key, sgkey);
}

◆ toIdentifiedObject() [1/2]

DataProxyHolder::sgkey_t SG::DataProxyHolder::toIdentifiedObject	(	const ID_type &	dataID,
		CLID	link_clid,
		IProxyDict *	sg )

Set the link to an object given by a string key.

Parameters

dataID	Key of the object.
link_clid	CLID of the link being set.
sg	Associated store.

Returns: The SG key for this object.

This will try to look up the proxy for dataID. If that succeeds, then we store the pointer to the proxy. Otherwise, we create a dummy proxy and add it to the store. We return the SG key in either case.

If sg is 0, then we take the store from whatever the link's currently set to. If the link has no current store, then we take the global default.

Definition at line 125 of file DataProxyHolder.cxx.

{
  // Find the store to use.
  if (sg == 0)
    sg = this->source1();
  if (sg == 0)
    sg = SG::CurrentEventStore::store();
 
  if (!sg)
    return 0;
 
  // Look up the proxy.
  m_proxy = sg->proxy (link_clid, dataID);
  if (m_proxy == 0) {
    // Didn't find a proxy; make a dummy.
    SG::TransientAddress tad (link_clid, dataID);
    tad.setSGKey (sg->stringToKey (dataID, link_clid));
    m_proxy = new SG::DataProxy (std::move(tad), static_cast<IConverter*>(nullptr));
    if (sg->addToStore (link_clid, m_proxy).isFailure())
      std::abort();
  }
 
  // Return the proxy's sgkey.
  return m_proxy->sgkey();
}

◆ toIdentifiedObject() [2/2]

void SG::DataProxyHolder::toIdentifiedObject	(	sgkey_t	sgkey,
		CLID	link_clid,
		IProxyDict *	sg )

Set the link to an object given by a hashed key.

Parameters

key	Hashed key of the object.
link_clid	CLID of the link being set.
sg	Associated store.

This will try to look up the proxy for key. If that succeeds, then we store the pointer to the proxy. Otherwise, we create a dummy proxy and add it to the store.

If sg is 0, then we take the store from whatever the link's currently set to. If the link has no current store, then we take the global default.

May throw ExcCLIDMismatch.

Definition at line 171 of file DataProxyHolder.cxx.

{
  if (!sgkey) return;
 
  // Find the store to use.
  if (sg == 0)
    sg = this->source1();
  if (sg == 0)
    sg = SG::CurrentEventStore::store();
 
  if (!sg)
    return;
 
  // Look up the proxy.
  m_proxy = sg->proxy_exact (sgkey);
 
  CLID clid = CLID_NULL;
  const std::string* key = nullptr;
  if (m_proxy == 0) {
    // Didn't find it --- have SG query proxy providers.
    // Try to turn the hashed key into a string key + clid.
    key = sg->keyToString (sgkey, clid);
    if (key) {
      if (link_clid != CLID_NULL && clid != link_clid)
        throw SG::ExcCLIDMismatch (clid, link_clid);
      m_proxy = sg->proxy (clid, *key);
    }
  }
  
  if (m_proxy == 0) {
    // Still didn't find it --- make a dummy.
    SG::TransientAddress tad;
    if (key) {
      tad = SG::TransientAddress (clid, *key);
    }
    tad.setSGKey (sgkey);
    m_proxy = new SG::DataProxy (std::move(tad), static_cast<IConverter*>(nullptr));
    if (sg->addToStore (clid, m_proxy).isFailure())
      std::abort();
  }
  else if (link_clid != CLID_NULL &&
           m_proxy->clID() != CLID_NULL &&
           !m_proxy->transientID(link_clid))
  {
    // Found a proxy, but types don't match.
    throw SG::ExcCLIDMismatch (m_proxy->clID(), link_clid);
  }
}

◆ toPersistent() [1/3]

template<class T>

bool SG::DataProxyHolder::toPersistent	(	sgkey_t &	sgkey,
		const T &	)

Prepare this link for writing.

Parameters

sgkey	Reference to the hashed SG key.
index	Index of this link.

One of the toPersistent methods should be called before trying to write the link with root.

This takes a reference to the hashed SG key. In the case where we're referencing an object directly by pointer, the hashed key will be 0. In that case, we try to look up the object in the default store. If we find it, the hashed key is updated appropriately; otherwise, we throw ExcPointerNotInSG.

This version is for the case where indices are not given by size_t. No remapping will be performed for this case; this function will always return false.

◆ toPersistent() [2/3]

bool SG::DataProxyHolder::toPersistent	(	sgkey_t &	sgkey,
		uint32_t &	index )

Prepare this link for writing.

Parameters

sgkey	Reference to the hashed SG key.
index	Index of this link.

One of the toPersistent methods should be called before trying to write the link with root.

This takes a reference to the hashed SG key. In the case where we're referencing an object directly by pointer, the hashed key will be 0. In that case, we try to look up the object in the default store. If we find it, the hashed key is updated appropriately; otherwise, we throw ExcPointerNotInSG.

If the target of the link has been remapped, then the sgkey and index parameters will be updated to reflect that, and true will be returned. Otherwise, if there was no remapping, then false will be returned.

This version is for the case where indices are given by uint32_t.

Definition at line 455 of file DataProxyHolder.cxx.

{
  toPersistentNoRemap (sgkey);
  size_t index_s = index;
  bool ret = tryRemap (sgkey, index_s);
  if (ret)
    index = static_cast<uint32_t>(index_s);
  return ret;
}

◆ toPersistent() [3/3]

bool SG::DataProxyHolder::toPersistent	(	sgkey_t &	sgkey,
		uint64_t &	index )

Prepare this link for writing.

Parameters

sgkey	Reference to the hashed SG key.
index	Index of this link.

One of the toPersistent methods should be called before trying to write the link with root.

This takes a reference to the hashed SG key. In the case where we're referencing an object directly by pointer, the hashed key will be 0. In that case, we try to look up the object in the default store. If we find it, the hashed key is updated appropriately; otherwise, we throw ExcPointerNotInSG.

If the target of the link has been remapped, then the sgkey and index parameters will be updated to reflect that, and true will be returned. Otherwise, if there was no remapping, then false will be returned.

This version is for the case where indices are given by uint64_t.

Definition at line 424 of file DataProxyHolder.cxx.

{
  toPersistentNoRemap (sgkey);
  size_t index_s = index;
  bool ret = tryRemap (sgkey, index_s);
  if (ret)
    index = index_s;
  return ret;
}

◆ toPersistentNoRemap()

void SG::DataProxyHolder::toPersistentNoRemap ( sgkey_t & sgkey )

Prepare this link for writing.

Parameters

sgkey Reference to the hashed SG key.

One of the toPersistent methods should be called before trying to write the link with root.

This takes a reference to the hashed SG key. In the case where we're referencing an object directly by pointer, the hashed key will be 0. In that case, we try to look up the object in the default store. If we find it, the hashed key is updated appropriately; otherwise, we throw ExcPointerNotInSG.

This version does not perform link remapping.

Definition at line 395 of file DataProxyHolder.cxx.

{
  if (!sgkey && m_proxy) {
    m_proxy = proxy(); // May throw.
    sgkey = m_proxy->sgkey();
  }
}

◆ toStorableObject()

DataProxyHolder::sgkey_t SG::DataProxyHolder::toStorableObject	(	const_pointer_t	obj,
		CLID	link_clid,
		IProxyDict *	sg )

Set the link to an object given by a pointer.

Parameters

obj	Pointer to the object.
link_clid	CLID of the link being set.
sg	Associated store.

Returns: The SG key for this object.

This will try to look up the proxy for obj. If that succeeds, then we store the pointer to the proxy and return the SG key. Otherwise, we store a pointer to the object itself, flagging this case with the low bit, and return 0.

If sg is 0, then we take the store from whatever the link's currently set to. If the link has no current store, then we take the global default.

May throw ExcCLIDMismatch.

Parameters

obj	Pointer to the object.
link_clid	CLID of the link being set.
sg	Associated store.

Returns: The SG key for this object.

This will try to look up the proxy for obj. If that succeeds, then we store the pointer to the proxy and return the SG key. Otherwise, we store a pointer to the object itself, flagging this case with the low bit, and return 0.

If sg is 0, then we take the store from whatever the link's currently set to. If the link has no current store, then we take the global default.

Definition at line 60 of file DataProxyHolder.cxx.

{
  sgkey_t key = 0;
  if (obj == 0) {
    // Setting the link to null.
    m_proxy = 0;
  }
  else {
    // Find the store to use.
    if (sg == 0)
      sg = this->source1();
    if (sg == 0)
      sg = SG::CurrentEventStore::store();
 
    if (sg) {
      m_proxy = sg->proxy (obj);
    }
    if (m_proxy == 0) {
      // Didn't find a proxy for this object.
      // Store the object pointer directly, and return 0.
      storeObjpointer (obj);
    }
    else {
      // Found a proxy.  Fetch the SG key and check that the type of the object
      // is consistent with the link type.
      key = m_proxy->sgkey();
      if (link_clid != m_proxy->clID() && !m_proxy->transientID (link_clid)) {
        if (m_proxy->clID() != CLID_NULL)
          throw SG::ExcCLIDMismatch (m_proxy->clID(), link_clid);
 
        // Transient clid was null.
        // This can happen when reading a view vector with xAODRootAccess
        // in an athena build, where the TAD may not get a CLID set.
        // Check based on key.
        if (sg) {
          sgkey_t link_sgkey = sg->stringToKey (m_proxy->name(), link_clid);
          if (link_sgkey != m_proxy->sgkey())
            throw SG::ExcCLIDMismatch (m_proxy->clID(), link_clid);
        }
      }
    }
  }
  return key;
}

◆ toTransient() [1/2]

DataProxyHolder::sgkey_t SG::DataProxyHolder::toTransient	(	const ID_type &	dataID,
		CLID	link_clid,
		IProxyDict *	sg = 0 )

Finish initialization after link has been read.

Parameters

dataID	Key of the object.
link_clid	CLID of the link being set.
sg	Associated store.

Returns: The hashed SG key for this object.

This should be called after a link has been read by root in order to set the proxy pointer. It calls toIdentifiedObject with the provided hashed key.

If sg is 0, then we use the global default store.

Definition at line 364 of file DataProxyHolder.cxx.

{
  // Find the store to use.
  if (sg == 0)
    sg = this->source1();
  if (sg == 0)
    sg = SG::CurrentEventStore::store();
 
  sgkey_t sgkey = sg->stringToKey (dataID, link_clid);
  toTransient (sgkey, sg);
  return sgkey;
}

◆ toTransient() [2/2]

void SG::DataProxyHolder::toTransient	(	sgkey_t	sgkey,
		IProxyDict *	sg = 0 )

Finish initialization after link has been read.

Parameters

sgkey	Hashed SG key.
sg	Associated store.

This should be called after a link has been read by root in order to set the proxy pointer. It calls toIdentifiedObject with the provided hashed key.

If sg is 0, then we use the global default store.

Definition at line 326 of file DataProxyHolder.cxx.

{
  m_proxy = 0;
 
  // Find the store to use.
  if (sg == 0)
    sg = this->source1();
  if (sg == 0)
    sg = SG::CurrentEventStore::store();
 
  // Do input renaming.
  if (s_inputRenameMap) {
    using InputRenameMap_t = Athena::InputRenameMap_t;
    Athena::RCURead<InputRenameMap_t> r (*s_inputRenameMap);
    auto it = r->find (sgkey);
    if (it != r->end())
      sgkey = it->second.m_sgkey;
  }
 
  if (sgkey)
    toIdentifiedObject (sgkey, CLID_NULL, sg);
}

◆ tryRemap()

bool SG::DataProxyHolder::tryRemap	(	sgkey_t &	sgkey,
		size_t &	index )

private

Test to see if the link has been remapped.

Parameters

sgkey	Reference to the hashed SG key.
index	Index of this link.

If this link has been remapped, sgkey and index will be adjusted accordingly.

Returns true if the link was remapped, false otherwise.

Definition at line 476 of file DataProxyHolder.cxx.

{
  if (sgkey) {
    // Check for remapping.
    sgkey_t sgkey_out;
    size_t index_out = 0;
    IProxyDict* sg = this->source();
    if (sg && sg->tryELRemap (sgkey, index, sgkey_out, index_out)) {
      this->toIdentifiedObject (sgkey_out, CLID_NULL, this->source());
      sgkey = sgkey_out;
      index = index_out;
      return true;
    }
  }
 
  return false;
}

Member Data Documentation

◆ m_proxy

SG::DataProxy* SG::DataProxyHolder::m_proxy

private

The DataProxy referring to our object, if the LSB is clear; pointer to the object which we're referencing directly if the LSB is set.

Definition at line 443 of file DataProxyHolder.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ castfn_t

◆ const_pointer_t

◆ ID_type

◆ pointer_t

◆ sgkey_t

Constructor & Destructor Documentation

◆ DataProxyHolder() [1/3]

◆ DataProxyHolder() [2/3]

◆ DataProxyHolder() [3/3]

Member Function Documentation

◆ clear()

◆ dataID()

◆ isDefault()

◆ isObjpointer()

◆ objpointer()

◆ operator=()

◆ operator==()

◆ proxy()

◆ proxy1()

◆ resetCachedSource()

◆ source()

◆ source1()

◆ storableBase()

◆ storeObjpointer()

◆ thin()

◆ throwInvalidLink()

◆ toIdentifiedObject() [1/2]

◆ toIdentifiedObject() [2/2]

◆ toPersistent() [1/3]

◆ toPersistent() [2/3]

◆ toPersistent() [3/3]

◆ toPersistentNoRemap()

◆ toStorableObject()

◆ toTransient() [1/2]

◆ toTransient() [2/2]

◆ tryRemap()

Member Data Documentation

◆ m_proxy