SG::UpdateHandle< T > Class Template Reference

#include <UpdateHandle.h>

Inheritance diagram for SG::UpdateHandle< T >:

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

Protected Member Functions
StatusCode	setState (SG::DataProxy *proxy)
	Set the state of the handle to a given proxy. More...
StatusCode	setState (IProxyDict *store, const std::string &name)
	Set the state of a handle from a store and a key name. More...
StatusCode	record_impl (std::unique_ptr< DataObject > dobj, void *dataPtr, bool allowMods, bool returnExisting)
	Helper to record an object in the event store. More...
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. More...
void *	typeless_dataPointer_impl (bool quiet)
	Retrieve an object from StoreGate. More...
void *	typeless_dataPointer (bool quiet=defaultQuiet)
	Retrieve an object from StoreGate. More...
const void *	typeless_cptr ()
	Retrieve an object from StoreGate as a const pointer. More...
void *	typeless_ptr (bool quiet=defaultQuiet)
	Retrieve an object from StoreGate as non-const pointer. More...
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. More...
bool	isPresent_impl (const std::string &key) const
	Is the referenced object present in SG? More...

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

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

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

Detailed Description

template<class T>
class SG::UpdateHandle< T >

Definition at line 89 of file UpdateHandle.h.

Member Typedef Documentation

const_pointer_type

template<class T >

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

Definition at line 94 of file UpdateHandle.h.

const_reference_type

template<class T >

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

Definition at line 96 of file UpdateHandle.h.

pointer_type

template<class T >

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

Definition at line 93 of file UpdateHandle.h.

reference_type

template<class T >

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

Definition at line 95 of file UpdateHandle.h.

Constructor & Destructor Documentation

UpdateHandle() [1/10]

template<class T >

SG::UpdateHandle< T >::UpdateHandle

(

)

Default constructor.

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

UpdateHandle() [2/10]

template<class T >

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

Constructor specifying the key as a string.

Parameters

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

UpdateHandle() [3/10]

template<class T >

SG::UpdateHandle< T >::UpdateHandle ( 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.

UpdateHandle() [4/10]

template<class T >

SG::UpdateHandle< T >::UpdateHandle ( 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.

UpdateHandle() [5/10]

template<class T >

SG::UpdateHandle< T >::UpdateHandle ( const UpdateHandleKey< T > &  key )

explicit

Constructor from an UpdateHandleKey.

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.

UpdateHandle() [6/10]

template<class T >

SG::UpdateHandle< T >::UpdateHandle ( const UpdateHandleKey< T > &  key, const EventContext &  ctx  )

explicit

Constructor from an UpdateHandleKey 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.

UpdateHandle() [7/10]

template<class T >

SG::UpdateHandle< T >::UpdateHandle ( SG::UpdateHandleKey< T > &&  key )

explicitdelete

UpdateHandle() [8/10]

template<class T >

SG::UpdateHandle< T >::UpdateHandle ( SG::UpdateHandleKey< T > &&  key, const EventContext &  ctx  )

explicitdelete

UpdateHandle() [9/10]

template<class T >

SG::UpdateHandle< T >::UpdateHandle

(

const UpdateHandle< T > &

rhs

)

Copy constructor.

UpdateHandle() [10/10]

template<class T >

SG::UpdateHandle< T >::UpdateHandle

(

UpdateHandle< T > &&

rhs

)

Move constructor.

Member Function Documentation

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 >

pointer_type SG::UpdateHandle< T >::cachedPtr

(

)

Return the cached pointer directly; no lookup.

checkedPtr()

template<class T >

pointer_type SG::UpdateHandle< T >::checkedPtr ( )

private

Helper: dereference the pointer.

Throws ExcNullUpdateHandle 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::UpdateHandle< T >::cptr

(

)

Dereference the pointer.

Returns nullptr on failure.

This will not inform Hive that the object has been modified.

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_impl()

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

protectedinherited

Definition at line 882 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 1107 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::UpdateHandle< 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 >

reference_type SG::UpdateHandle< T >::operator*

(

)

Dereference the pointer.

Throws ExcNullReadHandle on failure.

This will inform Hive that the object has been modified.

operator->()

template<class T >

pointer_type SG::UpdateHandle< T >::operator->

(

)

Dereference the pointer.

Throws ExcNullReadHandle on failure.

This will inform Hive that the object has been modified.

operator=() [1/2]

template<class T >

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

(

const UpdateHandle< T > &

rhs

)

Assignment operator.

operator=() [2/2]

template<class T >

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

(

UpdateHandle< T > &&

rhs

)

Move operator.

ptr()

template<class T >

pointer_type SG::UpdateHandle< T >::ptr

(

)

Dereference the pointer.

Returns nullptr on failure.

This will inform Hive that the object has been modified.

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 788 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;
    }
 
    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;
    }
 
    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() [1/2]

template<class T >

virtual void SG::UpdateHandle< T >::reset ( bool  hard )

overridevirtual

Reset this handle.

Parameters

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

Call reset() from the base class.

Reimplemented from SG::VarHandleBase.

reset() [2/2]

template<class T >

virtual void IResetable::reset

Clear cached data from this object.

If HARD is true, then also clear any data that depends on the identity of the current event store. HARD will be set if the handle could potentially be looking at a different store the next time it is used. (This happens in Hive.)

For example, a VarHandle caches both a pointer to the referenced object and a pointer to the DataProxy used to reference it. If HARD is false, then only the object pointer need be cleared; but if it is true, then the DataProxy pointer should be cleared as well (and the object deregistered from the store).

resetProxy()

void SG::VarHandleBase::resetProxy ( )

privateinherited

Clear the m_proxy field and release the old proxy.

Definition at line 1010 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 1026 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< DataVector, int >, SG::WriteDecorHandle< xAOD::TruthParticleContainer, llvec >, SG::WriteDecorHandle< DataVector, float >, SG::WriteDecorHandle< DataVector, std::vector< float > >, SG::WriteDecorHandle< DataVector, std::vector< int > >, SG::WriteDecorHandle< xAOD::TruthParticleContainer, uint8_t >, SG::WriteDecorHandle< DataVector, std::vector< bool > >, and SG::WriteDecorHandle< DataVector, uint32_t >.

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 993 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 963 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 932 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 1047 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 830 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 865 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:

• UpdateHandle.h