SG::DataProxyHolder Class Reference

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=nullptr, bool noDummy=false)
	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 60 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 74 of file DataProxyHolder.h.

const_pointer_t

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

Definition at line 71 of file DataProxyHolder.h.

ID_type

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

Type of string keys.

Definition at line 67 of file DataProxyHolder.h.

pointer_t

using SG::DataProxyHolder::pointer_t = void*

Generic pointer type.

Definition at line 70 of file DataProxyHolder.h.

sgkey_t

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

Type of hashed keys.

Definition at line 64 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 227 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 594 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 579 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 303 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 638 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 249 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 515 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 555 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 123 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 169 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 463 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 432 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 403 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 58 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 372 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 = nullptr,
		bool	noDummy = false )

Finish initialization after link has been read.

Parameters

sgkey	Hashed SG key.
sg	Associated store.
noDummy	If true, then if we don't find a proxy, just leave the link null rather than making a dummy.

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 nullptr, then we use the global default store.

Definition at line 326 of file DataProxyHolder.cxx.

{
  m_proxy = nullptr;
 
  // Find the store to use.
  if (sg == nullptr)
    sg = this->source1();
  if (sg == nullptr)
    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) {
    if (noDummy) {
      m_proxy = sg->proxy_exact (sgkey);
    }
    else {
      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 484 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 446 of file DataProxyHolder.h.

---

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

• DataProxyHolder.h
• DataProxy.cxx
• DataProxyHolder.cxx