SG::ReadHandle< T > Class Template Reference

#include <ReadHandle.h>

Inherits SG::VarHandleBase.

Inherited by SG::WriteDecorHandle< xAOD::MuonSegmentContainer, HitLinkVec_t >, SG::WriteDecorHandle< xAOD::MuonSegmentContainer, float >, SG::WriteDecorHandle< xAOD::MuonSegmentContainer, SegPars_t >, SG::WriteDecorHandle< PrdCont_t, bool >, SG::WriteDecorHandle< PrdCont_t, SegLinkVec_t >, SG::WriteDecorHandle< xAOD::IParticleContainer, float >, SG::WriteDecorHandle< xAOD::IParticleContainer, short >, SG::WriteDecorHandle< xAOD::JetContainer, int >, SG::WriteDecorHandle< xAOD::JetContainer, float >, SG::WriteDecorHandle< xAOD::TrackParticleContainer, bool >, and SG::WriteDecorHandle< container_t, xAOD::CaloRingsLinks >.

Collaboration diagram for SG::ReadHandle< T >:

Public Types
typedef T *	pointer_type
typedef const T *	const_pointer_type
typedef T &	reference_type
typedef const T &	const_reference_type

Public Member Functions
	ReadHandle ()
	Default constructor.
	ReadHandle (const std::string &sgkey, const std::string &storename=StoreID::storeName(StoreID::EVENT_STORE))
	Constructor specifying the key as a string.
	ReadHandle (const std::string &sgkey, const EventContext &ctx)
	Constructor specifying the key as a string, with context.
	ReadHandle (const std::string &sgkey, const std::string &storename, const EventContext &ctx)
	Constructor specifying the key as a string, with context.
	ReadHandle (const ReadHandleKey< T > &key)
	Constructor from a ReadHandleKey.
	ReadHandle (const ReadHandleKey< T > &key, const EventContext &ctx)
	Constructor from a ReadHandleKey and an explicit event context.
	ReadHandle (SG::DataProxy *proxy)
	Constructor from a DataProxy.
	ReadHandle (SG::ReadHandleKey< T > &&key)=delete
	ReadHandle (SG::ReadHandleKey< T > &&key, const EventContext &ctx)=delete
	ReadHandle (const ReadHandle &rhs)
	Copy constructor.
	ReadHandle (ReadHandle &&rhs)
	Move constructor.
ReadHandle &	operator= (const ReadHandle &rhs)
	Assignment operator.
ReadHandle &	operator= (ReadHandle &&rhs)
	Move operator.
const_pointer_type	operator-> ()
	Dereference the pointer.
const_reference_type	operator* ()
	Dereference the pointer.
const_pointer_type	cptr ()
	Dereference the pointer.
const_pointer_type	ptr ()
	Dereference the pointer.
const_pointer_type	cachedPtr () const
	Return the cached pointer directly; no lookup.
virtual bool	isValid () override final
	Can the handle be successfully dereferenced?
const_pointer_type	get () const
	Dereference the pointer, but don't cache anything.
const_pointer_type	get (const EventContext &ctx) const
	Dereference the pointer, but don't cache anything.
StatusCode	alias (const WriteHandleKey< T > &key)
	Make an alias.
virtual const std::string &	key () const override final
	Return the StoreGate ID for the referenced object.
const std::string &	name () const
	Return the StoreGate ID for the referenced object.
std::string	store () const
	Return the name of the store holding the object we are proxying.
bool	isPresent () const
	Is the referenced object present in SG?
bool	isInitialized () const
	Has a proxy been retrieved from SG?
virtual bool	isSet () const override final
	Has a proxy been retrieved from SG?
bool	isConst () const
	True if this handle has a proxy, and the proxy is const.
StatusCode	initialize (bool used=true)
	Verify that the handle has been configured properly.
StatusCode	setState ()
	Retrieve and cache all information managed by a handle.
virtual StatusCode	setProxyDict (IProxyDict *store)
	Explicitly set the event store.
virtual void	reset (bool hard) override
	Reset this handle.
virtual void	finalReset () override final
	Reset this handle at the end of processing.
StatusCode	setConst ()
	Set the 'const' bit for the bound proxy in the store.
CLID	clid () const
	Return the class ID for the referenced object.
const ServiceHandle< IProxyDict > &	storeHandle () const
	Return handle to the referenced store.
Gaudi::DataHandle::Mode	mode () const
	Return the mode (read/write/update) for this handle.
const std::string &	objKey () const
	Return the key string of the underlying DataObjID.
const DataObjID &	fullKey () const
	Return the key as a DataObjID.
SG::VarHandleKey &	vhKey ()
	Return a non-const reference to the HandleKey.
StatusCode	assign (const std::string &sgkey)
	Update the underlying key from a string.

Protected Member Functions
	ReadHandle (const VarHandleKey &key, const EventContext *ctx)
	Protected constructor used by WriteDecorHandle.
StatusCode	setState (SG::DataProxy *proxy)
	Set the state of the handle to a given proxy.
StatusCode	setState (IProxyDict *store, const std::string &name)
	Set the state of a handle from a store and a key name.
StatusCode	record_impl (std::unique_ptr< DataObject > dobj, void *dataPtr, bool allowMods, bool returnExisting)
	Helper to record an object in the event store.
const void *	put_impl (const EventContext *ctx, std::unique_ptr< DataObject > dobj, const void *dataPtr, bool allowMods, bool returnExisting, IProxyDict *&store) const
	Helper to record an object in the event store.
void *	typeless_dataPointer_impl (bool quiet)
	Retrieve an object from StoreGate.
void *	typeless_dataPointer (bool quiet=defaultQuiet)
	Retrieve an object from StoreGate.
const void *	typeless_cptr ()
	Retrieve an object from StoreGate as a const pointer.
void *	typeless_ptr (bool quiet=defaultQuiet)
	Retrieve an object from StoreGate as non-const pointer.
const void *	get_impl (const EventContext *ctx, bool quiet=defaultQuiet) const
StatusCode	symLink_impl (CLID newClid, const std::string &newKey)
	Make a symlink or alias to the object currently referenced by this handle.
bool	isPresent_impl (const std::string &key) const
	Is the referenced object present in SG?

Protected Attributes
void *	m_ptr
	The object to which we are bound.
SG::DataProxy *	m_proxy
	Proxy holding the object to which we are bound.
IProxyDict *	m_store
	Pointer to the store that owns the object.
bool	m_storeWasSet
	True if the store was set explicitly via setProxyDict.

Private Member Functions
const_pointer_type	checkedCPtr ()
	Helper: dereference the pointer.
IProxyDict *	storeFromHandle (const EventContext *ctx) const
	Return the store instance to use.
bool	setStoreFromHandle (const EventContext *ctx)
	Initialize the store pointer from the store handle.
void	resetProxy ()
	Clear the m_proxy field and release the old proxy.
void	setProxy (SG::DataProxy *proxy)
	Set a new proxy.
void *	typeless_dataPointer_fromProxy (SG::DataProxy *proxy, bool quiet) const
	Retrieve a pointer from a proxy.

Private Attributes
std::unique_ptr< VarHandleKey >	m_ownedKey
	An owned VarHandleKey.
const VarHandleKey *	m_key
	The associated key object.

Detailed Description

template<class T>
class SG::ReadHandle< T >

Definition at line 65 of file StoreGate/StoreGate/ReadHandle.h.

Member Typedef Documentation

const_pointer_type

template<class T>

typedef const T* SG::ReadHandle< T >::const_pointer_type

Definition at line 70 of file StoreGate/StoreGate/ReadHandle.h.

const_reference_type

template<class T>

typedef const T& SG::ReadHandle< T >::const_reference_type

Definition at line 72 of file StoreGate/StoreGate/ReadHandle.h.

pointer_type

template<class T>

typedef T* SG::ReadHandle< T >::pointer_type

Definition at line 69 of file StoreGate/StoreGate/ReadHandle.h.

reference_type

template<class T>

typedef T& SG::ReadHandle< T >::reference_type

Definition at line 71 of file StoreGate/StoreGate/ReadHandle.h.

Constructor & Destructor Documentation

ReadHandle() [1/12]

template<class T>

SG::ReadHandle< T >::ReadHandle

(

)

Default constructor.

The handle will not be usable until a non-blank key is assigned.

ReadHandle() [2/12]

template<class T>

SG::ReadHandle< T >::ReadHandle ( const std::string & sgkey, const std::string & storename = StoreID::storeName(StoreID::EVENT_STORE) )

explicit

Constructor specifying the key as a string.

Parameters

sgkey	StoreGate key of the referenced object.
storename	Name of the referenced event store.

ReadHandle() [3/12]

template<class T>

SG::ReadHandle< T >::ReadHandle ( const std::string & sgkey, const EventContext & ctx )

explicit

Constructor specifying the key as a string, with context.

Parameters

sgkey	StoreGate key of the referenced object.
ctx	The event context.

ReadHandle() [4/12]

template<class T>

SG::ReadHandle< T >::ReadHandle ( const std::string & sgkey, const std::string & storename, const EventContext & ctx )

explicit

Constructor specifying the key as a string, with context.

Parameters

sgkey	StoreGate key of the referenced object.
storename	Name of the referenced event store.
ctx	The event context.

ReadHandle() [5/12]

template<class T>

SG::ReadHandle< T >::ReadHandle ( const ReadHandleKey< T > & key )

explicit

Constructor from a ReadHandleKey.

Parameters

key	The key object holding the clid/key/store.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

ReadHandle() [6/12]

template<class T>

SG::ReadHandle< T >::ReadHandle ( const ReadHandleKey< T > & key, const EventContext & ctx )

explicit

Constructor from a ReadHandleKey and an explicit event context.

Parameters

key	The key object holding the clid/key.
ctx	The event context.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

If the default event store has been requested, then the thread-specific store from the event context will be used.

ReadHandle() [7/12]

template<class T>

SG::ReadHandle< T >::ReadHandle ( SG::DataProxy * proxy )

explicit

Constructor from a DataProxy.

Parameters

proxy	The proxy to which to bind.
mode	Mode of this handle (read/write/update).

This handle will be bound to the given proxy.

ReadHandle() [8/12]

template<class T>

SG::ReadHandle< T >::ReadHandle ( SG::ReadHandleKey< T > && key )

explicitdelete

ReadHandle() [9/12]

template<class T>

SG::ReadHandle< T >::ReadHandle ( SG::ReadHandleKey< T > && key, const EventContext & ctx )

explicitdelete

ReadHandle() [10/12]

template<class T>

SG::ReadHandle< T >::ReadHandle

(

const ReadHandle< T > &

rhs

)

Copy constructor.

ReadHandle() [11/12]

template<class T>

SG::ReadHandle< T >::ReadHandle

(

ReadHandle< T > &&

rhs

)

Move constructor.

ReadHandle() [12/12]

template<class T>

SG::ReadHandle< T >::ReadHandle ( const VarHandleKey & key, const EventContext * ctx )

explicitprotected

Protected constructor used by WriteDecorHandle.

Parameters

key	The key object holding the clid/key.
ctx	The event context, or nullptr to use the global default.

Member Function Documentation

alias()

template<class T>

StatusCode SG::ReadHandle< T >::alias

(

const WriteHandleKey< T > &

key

)

Make an alias.

Parameters

key	Alternate key by which the referenced object should be known.

The current handle should be valid and referencing an object.

The object will also be known by the name given in key.

assign()

StatusCode SG::VarHandleBase::assign ( const std::string & sgkey )

inherited

Update the underlying key from a string.

If this handle was initialized from a HandleKey, then this doesn't work (since the HandleKey is const). ExcNonConstHandleKey will be thrown in that case.

See VarHandleKey::assign.

Definition at line 648 of file StoreGate/src/VarHandleBase.cxx.

  {
    return vhKey().assign (sgkey);
  }

cachedPtr()

template<class T>

const_pointer_type SG::ReadHandle< T >::cachedPtr

(

)

const

Return the cached pointer directly; no lookup.

checkedCPtr()

template<class T>

const_pointer_type SG::ReadHandle< T >::checkedCPtr ( )

private

Helper: dereference the pointer.

Throws ExcNullReadHandle on failure.

clid()

CLID SG::VarHandleBase::clid ( ) const

inherited

Return the class ID for the referenced object.

cptr()

template<class T>

const_pointer_type SG::ReadHandle< T >::cptr

(

)

Dereference the pointer.

Returns nullptr on failure.

finalReset()

void SG::VarHandleBase::finalReset ( )

finaloverridevirtualinherited

Reset this handle at the end of processing.

hard If true, anything depending on the event store is cleared.

Same as reset(true);

Reimplemented from IResetable.

Definition at line 601 of file StoreGate/src/VarHandleBase.cxx.

                                 {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::finalReset {} with proxy={}, key={}, store={}\n", dbg::ptr(this), dbg::proxy(m_proxy), this->key(), dbg::store(this->m_store));
#endif
    reset (true);
  }

fullKey()

const DataObjID & SG::VarHandleBase::fullKey ( ) const

inherited

Return the key as a DataObjID.

get() [1/2]

template<class T>

const_pointer_type SG::ReadHandle< T >::get

(

)

const

Dereference the pointer, but don't cache anything.

get() [2/2]

template<class T>

const_pointer_type SG::ReadHandle< T >::get

(

const EventContext &

ctx

)

const

Dereference the pointer, but don't cache anything.

Parameters

ctx	The event context to use.

get_impl()

const void * SG::VarHandleBase::get_impl ( const EventContext * ctx, bool quiet = defaultQuiet ) const

protectedinherited

Definition at line 890 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (this->mode() != Gaudi::DataHandle::Reader) {
      if (!quiet)
        REPORT_ERROR (StatusCode::FAILURE)
          << "get_impl called for a non-read handle.";
      return nullptr;
    }
 
    if (this->key().empty()) {
      if (!quiet)
        REPORT_ERROR (StatusCode::FAILURE)
          << "Cannot initialize a Read/Write/Update handle with a null key.";
      return nullptr;
    }
 
    IProxyDict* store = storeFromHandle (ctx);
    if (!store) {
      if (!quiet)
        REPORT_ERROR (StatusCode::FAILURE) << "No store.";
      return nullptr;
    }
 
    SG::DataProxy* proxy = store->proxy_exact(m_key->hashedKey());
    if (!proxy) {
      proxy = store->proxy(this->clid(), this->key());
      if (!proxy) {
        if (!quiet)
          REPORT_ERROR (StatusCode::FAILURE)
            << "Cannot find proxy for "
            << this->clid() << "/" << this->key();
        return nullptr;
      }
    }
 
    return typeless_dataPointer_fromProxy (proxy, quiet);
  }

initialize()

StatusCode SG::VarHandleBase::initialize ( bool used = true )

inherited

Verify that the handle has been configured properly.

Parameters

used	If false, then this handle is not to be used. Instead of normal initialization, the key will be cleared.

This will return failure if the key is blank or if the event store cannot be found.

Definition at line 458 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (!used) {
      if (m_ownedKey) {
        CHECK( m_ownedKey->initialize (used) );
      }
      return StatusCode::SUCCESS;
    }
 
    if (!m_store) {
      if (m_ownedKey) {
        CHECK( m_ownedKey->initialize() );
      }
      m_store = &*(this->storeHandle());
      m_storeWasSet = false;
    }
 
    if (!m_store) {
      return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
  }

isConst()

bool SG::VarHandleBase::isConst ( ) const

inherited

True if this handle has a proxy, and the proxy is const.

Refers to the state of the proxy, not of the handle.

Definition at line 438 of file StoreGate/src/VarHandleBase.cxx.

  {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::isConst({}, proxy={}) const\n", dbg::ptr(this), dbg::proxy(m_proxy));
#endif
    return 0 != m_proxy 
      ? m_proxy->isConst() 
      : false;
  }

isInitialized()

bool SG::VarHandleBase::isInitialized ( ) const

inherited

Has a proxy been retrieved from SG?

(Weaker test than isValid, but does not touch the disk.)

Definition at line 412 of file StoreGate/src/VarHandleBase.cxx.

  {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::isInitialized({}, proxy={}) const\n", dbg::ptr(this), dbg::proxy(m_proxy));
#endif
    return (0 != m_proxy);
  }

isPresent()

bool SG::VarHandleBase::isPresent ( ) const

inherited

Is the referenced object present in SG?

Const method; the handle does not change as a result of this.

Definition at line 400 of file StoreGate/src/VarHandleBase.cxx.

  {
    return isPresent_impl (key());
  }

isPresent_impl()

bool SG::VarHandleBase::isPresent_impl ( const std::string & key ) const

protectedinherited

Is the referenced object present in SG?

Parameters

key	SG key to test.

Const method; the handle does not change as a result of this.

Definition at line 1115 of file StoreGate/src/VarHandleBase.cxx.

  {
    const DataProxy* proxy = m_proxy;
    if (!proxy) {
      const IProxyDict* store = m_store;
      if (!store)
        store = this->storeHandle().get();
      if (store)
        proxy = store->proxy(this->clid(), key);
    }
    if (proxy) {
      return proxy->isValid();
    }
    return false;
  }

isSet()

bool SG::VarHandleBase::isSet ( ) const

finaloverridevirtualinherited

Has a proxy been retrieved from SG?

Same as isInitialized; this is an interface required by IResetable.

Implements IResetable.

Definition at line 426 of file StoreGate/src/VarHandleBase.cxx.

  {
    return isInitialized();
  }

isValid()

template<class T>

virtual bool SG::ReadHandle< T >::isValid ( )

finaloverridevirtual

Can the handle be successfully dereferenced?

Implements SG::VarHandleBase.

key()

const std::string & SG::VarHandleBase::key ( ) const

finaloverridevirtualinherited

Return the StoreGate ID for the referenced object.

This is defined in VarHandleKey. We need to redefine it here because it's also in IResetable. (Otherwise there would be an ambiguity.)

Implements IResetable.

Definition at line 64 of file AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx.

  {
    return m_key->key();
  }

mode()

Gaudi::DataHandle::Mode SG::VarHandleBase::mode ( ) const

inherited

Return the mode (read/write/update) for this handle.

name()

const std::string & SG::VarHandleBase::name ( ) const

inherited

Return the StoreGate ID for the referenced object.

A synonym for key().

Definition at line 75 of file AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx.

  {
    return this->key();
  }

objKey()

const std::string & SG::VarHandleBase::objKey ( ) const

inherited

Return the key string of the underlying DataObjID.

Compared to key(), this will be prefixed with the store name.

operator*()

template<class T>

const_reference_type SG::ReadHandle< T >::operator*

(

)

Dereference the pointer.

Throws ExcNullReadHandle on failure.

operator->()

template<class T>

const_pointer_type SG::ReadHandle< T >::operator->

(

)

Dereference the pointer.

Throws ExcNullReadHandle on failure.

operator=() [1/2]

template<class T>

ReadHandle & SG::ReadHandle< T >::operator=

(

const ReadHandle< T > &

rhs

)

Assignment operator.

operator=() [2/2]

template<class T>

ReadHandle & SG::ReadHandle< T >::operator=

(

ReadHandle< T > &&

rhs

)

Move operator.

ptr()

template<class T>

const_pointer_type SG::ReadHandle< T >::ptr

(

)

Dereference the pointer.

Returns nullptr on failure.

put_impl()

const void * SG::VarHandleBase::put_impl ( const EventContext * ctx, std::unique_ptr< DataObject > dobj, const void * dataPtr, bool allowMods, bool returnExisting, IProxyDict *& store ) const

protectedinherited

Helper to record an object in the event store.

Unlike record, put does not change the handle and does not cache the pointer in the handle.

Parameters

	ctx	The event context, or nullptr to use the current context.
	dobj	The wrapped data object (DataBucket) to record.
	dataPtr	Pointer to the transient object itself.
	allowMods	If false, record the object as const.
	returnExisting	Allow an existing object.
[out]	store	The store being used.

Returns the object placed in the store, or nullptr if there was an error. If there was already an object in the store with the given key, then return null, unless returnExisting is true, in which case return success. In either case, dobj is destroyed.

Definition at line 792 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (this->name().empty()) {
      REPORT_ERROR (StatusCode::FAILURE) << "Attempt to record an object with a null key";
      return nullptr;
    }
 
    store = storeFromHandle (ctx);
    if (!store) {
      REPORT_ERROR (StatusCode::FAILURE) << "No store.";
      return nullptr;
    }
    if (!dobj) {
      REPORT_ERROR (StatusCode::FAILURE) << "Attempt to record null pointer.";
      return nullptr;
    }
 
    SG::DataObjectSharedPtr<DataObject> sptr (std::move (dobj));
    unsigned int initRefCount = sptr->refCount();
    SG::DataProxy* new_proxy = 
      store->recordObject (sptr, this->name(), allowMods, returnExisting);
    if (!new_proxy) {
      REPORT_ERROR (StatusCode::FAILURE) << "recordObject failed";
      return nullptr;
    }
  
    if (new_proxy && initRefCount == sptr->refCount() && new_proxy->isValid()) {
      // If the reference count hasn't changed, then we've returned an existing
      // object rather than recording a new one.  Retrieve the pointer.
      dataPtr = typeless_dataPointer_fromProxy (new_proxy, true);
    }
 
    return dataPtr;
  }

record_impl()

StatusCode SG::VarHandleBase::record_impl ( std::unique_ptr< DataObject > dobj, void * dataPtr, bool allowMods, bool returnExisting )

protectedinherited

Helper to record an object in the event store.

Parameters

The	wrapped data object (DataBucket) to record.
dataPtr	Pointer to the transient object itself.
allowMods	If false, record the object as const.
returnExisting	Allow an existing object.

If there is already an existing object with our key, then return failure, unless returnExisting is true, in which case return success. In either case, dobj is destroyed.

Definition at line 719 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (!m_store) {
      if (m_ownedKey) {
        CHECK (m_ownedKey->initialize());
      }
      m_store = &*(this->storeHandle());
      m_storeWasSet = false;
    }
 
    if (this->name().empty()) {
      REPORT_ERROR (StatusCode::FAILURE) << "Attempt to record an object with a null key";
      return StatusCode::FAILURE;
    }
    if (!dobj) {
      REPORT_ERROR (StatusCode::FAILURE) << "Attempt to record null pointer";
      return StatusCode::FAILURE;
    }
 
    SG::DataObjectSharedPtr<DataObject> sptr (dobj.release());
    unsigned int initRefCount = sptr->refCount();
    SG::DataProxy* new_proxy = 
      m_store->recordObject (sptr, this->name(), allowMods, returnExisting);
    if (!new_proxy) {
      REPORT_ERROR (StatusCode::FAILURE) << "recordObject failed";
      resetProxy();
      return StatusCode::FAILURE;
    }
    if (m_proxy != new_proxy) {
      CHECK (this->setState (new_proxy));
    }
  
    if (new_proxy && initRefCount == sptr->refCount() && new_proxy->isValid()) {
      // If the reference count hasn't changed, then we've returned an existing
      // object rather than recording a new one.  Retrieve the pointer, making
      // sure that it isn't const.
      if (m_proxy->isConst()) {
        REPORT_ERROR (StatusCode::FAILURE)
          << "Found an existing const object from recordOrRetrieve.";
        return StatusCode::FAILURE;
      }
      m_ptr = typeless_dataPointer_impl(true);
      if (!allowMods)
        CHECK( setConst() );
    }
    else
      m_ptr=(void*)dataPtr;
 
    return StatusCode::SUCCESS;
  }

reset()

void SG::VarHandleBase::reset ( bool hard )

overridevirtualinherited

Reset this handle.

Parameters

hard	If true, anything depending on the event store is cleared.

If the handle stays associated with a given event store, then hard=false. In that case, we clear the cached pointer; the proxy is also dropped if it is reset only. If hard=true, then we always drop the proxy and in addition clear the cached pointer to the event store.

Implements IResetable.

Reimplemented in SG::UpdateHandle< T >, and SG::UpdateHandle< IDCBackend >.

Definition at line 576 of file StoreGate/src/VarHandleBase.cxx.

                                 {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::reset {} with proxy={}, key={}, store={} (hard={})\n", dbg::ptr(this), dbg::proxy(m_proxy), this->key(), dbg::store(this->m_store), hard);
#endif
    m_ptr = 0; 
 
    if (hard) {
      m_store = 0;
      m_storeWasSet = false;
    }
 
    //if the proxy is not resetOnly then release it as it will become invalid
    // Also release on a hard reset.
    if (0 != m_proxy && (!m_proxy->isResetOnly() || hard)) {
      resetProxy();
    }
  }

resetProxy()

void SG::VarHandleBase::resetProxy ( )

privateinherited

Clear the m_proxy field and release the old proxy.

Definition at line 1018 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (m_proxy) {
      if (m_ownedKey) {
        m_proxy->unbindHandle(this);
        m_proxy->release();
      }
      m_proxy = nullptr;
    }
  }

setConst()

StatusCode SG::VarHandleBase::setConst ( )

inherited

Set the 'const' bit for the bound proxy in the store.

Definition at line 612 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (typeless_dataPointer()) {
      m_proxy->setConst();
      return StatusCode::SUCCESS;
    }
    return StatusCode::FAILURE;
  }

setProxy()

void SG::VarHandleBase::setProxy ( SG::DataProxy * proxy )

privateinherited

Set a new proxy.

Release any old one first.

Parameters

proxy

The new proxy.

Definition at line 1034 of file StoreGate/src/VarHandleBase.cxx.

  {
    resetProxy();
    if (proxy) {
      if (m_ownedKey) {
        proxy->addRef();
        proxy->bindHandle (this);
      }
      m_proxy = proxy;
    }
  }

setProxyDict()

StatusCode SG::VarHandleBase::setProxyDict ( IProxyDict * store )

virtualinherited

Explicitly set the event store.

Parameters

store

The new event store.

This implicitly does a reset().

Reimplemented in SG::WriteDecorHandle< container_t, xAOD::CaloRingsLinks >, SG::WriteDecorHandle< DataVector< IParticle >, float >, SG::WriteDecorHandle< DataVector< IParticle >, uint32_t >, SG::WriteDecorHandle< DataVector< xAOD::Electron_v1 >, float >, SG::WriteDecorHandle< DataVector< xAOD::Electron_v1 >, int >, SG::WriteDecorHandle< DataVector< xAOD::Jet_v1 >, float >, SG::WriteDecorHandle< DataVector< xAOD::Jet_v1 >, std::vector< float > >, SG::WriteDecorHandle< DataVector< xAOD::Jet_v1 >, std::vector< int > >, SG::WriteDecorHandle< DataVector< xAOD::TrackParticle_v1 >, float >, SG::WriteDecorHandle< DataVector< xAOD::TrackParticle_v1 >, std::vector< bool > >, SG::WriteDecorHandle< DataVector< xAOD::TrackParticle_v1 >, std::vector< float > >, SG::WriteDecorHandle< DataVector< xAOD::TrackParticle_v1 >, std::vector< int > >, SG::WriteDecorHandle< PrdCont_t, bool >, SG::WriteDecorHandle< PrdCont_t, SegLinkVec_t >, SG::WriteDecorHandle< xAOD::CaloClusterContainer, std::vector< ElementLink< xAOD::CaloClusterContainer > > >, SG::WriteDecorHandle< xAOD::IParticleContainer, float >, SG::WriteDecorHandle< xAOD::IParticleContainer, short >, SG::WriteDecorHandle< xAOD::JetContainer, float >, SG::WriteDecorHandle< xAOD::JetContainer, int >, SG::WriteDecorHandle< xAOD::MuonSegmentContainer, float >, SG::WriteDecorHandle< xAOD::MuonSegmentContainer, HitLinkVec_t >, SG::WriteDecorHandle< xAOD::MuonSegmentContainer, SegPars_t >, and SG::WriteDecorHandle< xAOD::TrackParticleContainer, bool >.

Definition at line 557 of file StoreGate/src/VarHandleBase.cxx.

  {
    reset(true);
    m_store = store;
    m_storeWasSet = true;
    return StatusCode::SUCCESS;
  }

setState() [1/3]

StatusCode SG::VarHandleBase::setState ( )

inherited

Retrieve and cache all information managed by a handle.

This will retrieve and cache the associated DataProxy.

Note for the case of a WriteHandle that has not yet been written to, the proxy may not exist. We return Success in that case; however, isInitialized will still return false.

Definition at line 493 of file StoreGate/src/VarHandleBase.cxx.

  {
    CHECK( initialize() );
    if (!m_storeWasSet) {
      IProxyDict* store = storeFromHandle (nullptr);
      if (store) m_store = store;
    }
 
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB:: setState() on {} with key={} ({}) and store={} (CLID: {})\n", dbg::ptr(this), this->key(), m_key->hashedKey(), dbg::store(m_store), this->clid());
#endif
 
    SG::DataProxy* proxy = m_store->proxy_exact (m_key->hashedKey());
    if (!proxy) {
#ifdef DEBUG_VHB
      dbg::print(stderr, "::VHB:: setState() on {} ==> null proxy!\n", dbg::ptr(this));
#endif
      proxy = m_store->proxy(this->clid(), this->key());
    }
 
    if (!proxy) {
#ifdef DEBUG_VHB
      dbg::print(stderr, "::VHB:: setState() on {} ==> STILL null proxy!\n", dbg::ptr(this));
#endif
    }
    else if (!proxy->isValid()) {
#ifdef DEBUG_VHB
      dbg::print(stderr, "::VHB:: setState() on {} ==> proxy not valid! Dumping Store\n", dbg::ptr(this));
      if (!m_store) {
        dbg::print(stderr, "::VHB:: setState() on {} ==> m_store is a nullptr\n", dbg::ptr(this));
      }
      else {
        SGImplSvc* stor = dynamic_cast<SGImplSvc*>(m_store);
        if (!stor) {
          dbg::print(stderr, "::VHB:: setState() on {} ==> m_store points not to an SGImplSvc but to a {}\n", dbg::ptr(this), boost::core::demangle(typeid(*m_store).name()));
        }
        else {
          dbg::print(stderr, "\n{}\n", stor->dump());
        }
      }
#endif
    }
    StatusCode sc = this->setState(proxy);
 
    // Failure to find the proxy is ok in the case of a @c WriteHandle
    // that has not yet been written to.
    if (sc.isFailure() && mode() == Gaudi::DataHandle::Writer && m_ptr == nullptr)
      return StatusCode::SUCCESS;
 
    return sc;
  }

setState() [2/3]

StatusCode SG::VarHandleBase::setState ( IProxyDict * store, const std::string & key )

protectedinherited

Set the state of a handle from a store and a key name.

Parameters

store	The event store to access.
name	The StoreGate key to search for.

Fails if no such object is recorded.

Parameters

store	The event store to access.
name	The StoreGate key to search for.

Definition at line 692 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (0 == store) {
      return StatusCode::FAILURE;
    }
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::setState({}, store={}, key={}) const\n", dbg::ptr(this), dbg::store(store), key);
#endif
    CLID cid = this->clid();
    SG::DataProxy* proxy = store->proxy(cid, key);
    // std::cerr << "::VHB:: -- clid=[" << cid << "] proxy=[" << proxy << "]\n";
    return this->setState(proxy);
  }

setState() [3/3]

StatusCode SG::VarHandleBase::setState ( SG::DataProxy * proxy )

protectedinherited

Set the state of the handle to a given proxy.

Parameters

proxy

The proxy to set.

The proxy must be valid; otherwise FAILURE will be returned.

Definition at line 666 of file StoreGate/src/VarHandleBase.cxx.

  {
#ifdef DEBUG_VHB
      dbg::print(stderr, "::VHB::setState({}, proxy={}) const\n", dbg::ptr(this), dbg::proxy(proxy));
#endif
    if (0 == proxy || !proxy->isValid()) {
      return StatusCode::FAILURE;
    }
 
    if (m_proxy != proxy) {
      // We're changing proxies.  Release the old and bind to the new.
      setProxy (proxy);
      // Clear cached pointer.
      m_ptr=0;
    }
 
    return StatusCode::SUCCESS;
  }

setStoreFromHandle()

bool SG::VarHandleBase::setStoreFromHandle ( const EventContext * ctx )

privateinherited

Initialize the store pointer from the store handle.

Also checks that the key is valid.

Parameters

ctx	The current event context, or nullptr.

Returns true on success.

Definition at line 1001 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (m_ownedKey) {
      if (m_ownedKey->initialize().isFailure()) {
        return false;
      }
    }
    m_store = storeFromHandle (ctx);
    m_storeWasSet = (ctx && m_store ==
                     Atlas::getExtendedEventContext(*ctx).proxy());
    return true;
  }

store()

std::string SG::VarHandleBase::store ( ) const

inherited

Return the name of the store holding the object we are proxying.

Definition at line 382 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (m_store)
      return m_store->name();
    return this->storeHandle().name();
  }

storeFromHandle()

IProxyDict * SG::VarHandleBase::storeFromHandle ( const EventContext * ctx ) const

privateinherited

Return the store instance to use.

Parameters

ctx	The current event context, or nullptr.
ctx	The current event context, or nullptr.

If we're referencing the default event store, pick the specific store to use in this order:

• Store associated with an explicitly-provided context.
• A store explicitly set via setProxyDict.
• Store associated with the current context.

For another store:

• A store explicitly set via setProxyDict.
• The store retrieved from the handle, resolved to the current slot if it's a hive store.

Definition at line 971 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (m_key->isEventStore()) {
      if (ctx)
        return Atlas::getExtendedEventContext(*ctx).proxy();
      if (m_storeWasSet && m_store) return m_store;
 
      if ( Atlas::hasExtendedEventContext (Gaudi::Hive::currentContext()) ) {
        return Atlas::getExtendedEventContext (Gaudi::Hive::currentContext()).proxy();
      } else {
        return nullptr;
      }
    }
 
    if (m_storeWasSet && m_store) return m_store;
    IProxyDict* store = m_store;
    if (!store)
      store = &*this->storeHandle();
 
    return store->hiveProxyDict();
  }

storeHandle()

const ServiceHandle< IProxyDict > & SG::VarHandleBase::storeHandle ( ) const

inherited

Return handle to the referenced store.

symLink_impl()

StatusCode SG::VarHandleBase::symLink_impl ( CLID newClid, const std::string & newKey )

protectedinherited

Make a symlink or alias to the object currently referenced by this handle.

Parameters

newClid	CLID of link.
newKey	SG key of link.

If newClid matches the existing clid, then make an alias. If newKey matches the existing key, then make a symlink. If neither match, it's an error.

Definition at line 940 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (!m_ptr || !m_store) {
      REPORT_ERROR (StatusCode::FAILURE) << "symlink: Handle not valid.";
      return StatusCode::FAILURE;
    }
    
    SG::DataObjectSharedPtr<DataObject> obj (new SymlinkDataObject (newClid, m_ptr));
    SG::DataProxy* prox = m_store->recordObject (obj, newKey, false, true);
    if (!prox)
      return StatusCode::FAILURE;
    return StatusCode::SUCCESS;
  }

typeless_cptr()

const void * SG::VarHandleBase::typeless_cptr ( )

protectedinherited

Retrieve an object from StoreGate as a const pointer.

Same as typeless_dataPointer with the return value converted to const.

typeless_dataPointer()

void * SG::VarHandleBase::typeless_dataPointer ( bool quiet = defaultQuiet )

protectedinherited

Retrieve an object from StoreGate.

Parameters

quiet

If true, suppress failure messages.

Inline method: first check cached pointer, then call the _impl method.

typeless_dataPointer_fromProxy()

void * SG::VarHandleBase::typeless_dataPointer_fromProxy ( SG::DataProxy * proxy, bool quiet ) const

privateinherited

Retrieve a pointer from a proxy.

Parameters

proxy	The proxy object.
quiet	If true, suppress failure messages.

Warning — doesn't enforce const rules; the caller must do that.

Definition at line 1055 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (!proxy || !proxy->isValid()) {
      // invalid proxy
      if (!quiet) {
        REPORT_MESSAGE(MSG::WARNING)
          << "Proxy "
          << " [" << (proxy != 0 ? proxy->clID() : 0)
          << "/" << (proxy != 0 
                     ? proxy->name() 
                     : std::string("<N/A>"))
          << "] is in an invalid state";
      } //quiet
      return nullptr;
    }
 
    DataObject* dobj = proxy->accessData();
    if (!dobj) {
      // invalid dobj
      if (!quiet) {
        REPORT_MESSAGE(MSG::WARNING)
          << "this proxy " << MSG::hex << proxy
          << MSG::dec << " has a NULL data object ptr";
      }
      return nullptr;
    }
 
    const CLID clid = this->clid();
    void* ptr = SG::Storable_cast(dobj, clid, nullptr, true, proxy);
    if (ptr)
      return ptr;
 
    // If ptr is null, probably the clid we gave wasn't the clid
    // the object was stored with, nor it inherits from it.
    // before giving up, let's check its transient CLIDs
    DataBucketBase *dbb = 0;
    if (proxy->transientID(clid) &&
        0 != (dbb = dynamic_cast<DataBucketBase*>(dobj))) {
      // it is a symlink after all.
      // Let's hard cast (and keep our fingers Xed)
      ptr = static_cast<void*>(dbb->object());
    } else {
      if (!quiet) {
        REPORT_MESSAGE(MSG::WARNING)
          << "Request for an invalid object; requested CLID = " 
          << clid 
          << ", proxy primary ID is " << proxy->clID();
      }
    } // try symlink -- endif
    return ptr;
  }

typeless_dataPointer_impl()

void * SG::VarHandleBase::typeless_dataPointer_impl ( bool quiet )

protectedinherited

Retrieve an object from StoreGate.

Parameters

quiet

If true, suppress failure messages.

Definition at line 838 of file StoreGate/src/VarHandleBase.cxx.

  {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::typeless_dataPointer_impl({}, ptr={}, proxy={}, key={}, store={})\n", dbg::ptr(this), dbg::ptr(this->m_ptr), dbg::proxy(this->m_proxy), this->key(), dbg::store(this->m_store));
#endif
 
    // First check for cached pointer.
    if (0 != m_ptr)
      return m_ptr;
 
    if (0 == m_proxy) {
      // No proxy, need to look it up.
      if (this->setState().isFailure() || !m_proxy) {
        if (!quiet) {
          REPORT_MESSAGE(MSG::WARNING)
            << "could not get proxy for key " << key();
          if (this->mode() != Gaudi::DataHandle::Reader) {
            REPORT_MESSAGE(MSG::WARNING)<< " try using a ReadHandle";
          }
        } //quiet
        return 0;
      } //setstate
    } //m_proxy
 
    m_ptr = typeless_dataPointer_fromProxy (m_proxy, quiet);
    return m_ptr;
  }

typeless_ptr()

void * SG::VarHandleBase::typeless_ptr ( bool quiet = defaultQuiet )

protectedinherited

Retrieve an object from StoreGate as non-const pointer.

Calls typeless_dataPointer, then raises an exception if the proxy is marked as const.

Definition at line 873 of file StoreGate/src/VarHandleBase.cxx.

  {
    void* p = typeless_dataPointer(quiet);
    if (p != nullptr && isConst())
      throw SG::ExcConstObject (clid(), key(), store());
    return p;
  }

vhKey()

SG::VarHandleKey & SG::VarHandleBase::vhKey ( )

inherited

Return a non-const reference to the HandleKey.

If this handle was initialized from a HandleKey, then this doesn't work (since the HandleKey is const). ExcNonConstHandleKey will be thrown in that case.

Definition at line 629 of file StoreGate/src/VarHandleBase.cxx.

  {
    if (!m_ownedKey) {
      throwExcNonConstHandleKey (m_key->clid(), m_key->key(),
                                 m_key->storeHandle().name());
    }
    return *m_ownedKey;
  }

Member Data Documentation

m_key

const VarHandleKey* SG::VarHandleBase::m_key

privateinherited

The associated key object.

If we were initialized from a key object, then this points at that. Otherwise, it points at the same object as m_ownedKey.

Definition at line 525 of file StoreGate/StoreGate/VarHandleBase.h.

m_ownedKey

std::unique_ptr<VarHandleKey> SG::VarHandleBase::m_ownedKey

privateinherited

An owned VarHandleKey.

This is set in the case where a VarHandle is not initialized from a key object.

Definition at line 520 of file StoreGate/StoreGate/VarHandleBase.h.

m_proxy

SG::DataProxy* SG::VarHandleBase::m_proxy

protectedinherited

Proxy holding the object to which we are bound.

Definition at line 507 of file StoreGate/StoreGate/VarHandleBase.h.

m_ptr

void* SG::VarHandleBase::m_ptr

protectedinherited

The object to which we are bound.

Definition at line 504 of file StoreGate/StoreGate/VarHandleBase.h.

m_store

IProxyDict* SG::VarHandleBase::m_store

protectedinherited

Pointer to the store that owns the object.

Definition at line 510 of file StoreGate/StoreGate/VarHandleBase.h.

m_storeWasSet

bool SG::VarHandleBase::m_storeWasSet

protectedinherited

True if the store was set explicitly via setProxyDict.

Definition at line 513 of file StoreGate/StoreGate/VarHandleBase.h.

---

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

• StoreGate/StoreGate/ReadHandle.h