SG::WriteHandle< T > Class Template Reference

#include <WriteHandle.h>

Inheritance diagram for SG::WriteHandle< T >:

Collaboration diagram for SG::WriteHandle< 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
	WriteHandle ()
	Default constructor.
	WriteHandle (const std::string &sgkey, const std::string &storename=StoreID::storeName(StoreID::EVENT_STORE))
	Constructor specifying the key as a string.
	WriteHandle (const std::string &sgkey, const EventContext &ctx)
	Constructor specifying the key as a string, with context.
	WriteHandle (const std::string &sgkey, IProxyDict *sg)
	Constructor specifying the key as a string, with data store.
	WriteHandle (const std::string &sgkey, const std::string &storename, const EventContext &ctx)
	Constructor specifying the key as a string, with context.
	WriteHandle (const WriteHandleKey< T > &key)
	Constructor from a WriteHandleKey.
	WriteHandle (const WriteHandleKey< T > &key, const EventContext &ctx)
	Constructor from a WriteHandleKey and an explicit event context.
	WriteHandle (SG::WriteHandleKey< T > &&key)=delete
	WriteHandle (SG::WriteHandleKey< T > &&key, const EventContext &ctx)=delete
	WriteHandle (const WriteHandle &rhs)
	Copy constructor.
	WriteHandle (WriteHandle &&rhs) noexcept
	Move constructor.
WriteHandle &	operator= (const WriteHandle &rhs)
	Assignment operator.
WriteHandle &	operator= (WriteHandle &&rhs) noexcept
	Move operator.
	~WriteHandle ()
	Destructor.
pointer_type	operator-> ()
	Dereference the pointer.
reference_type	operator* ()
	Dereference the pointer.
const_pointer_type	cptr () const
	Dereference the pointer.
pointer_type	ptr ()
	Dereference the pointer.
pointer_type	cachedPtr ()
	Return the cached pointer directly; no lookup.
virtual bool	isValid () override final
	Can the handle be successfully dereferenced?
StatusCode	record (std::unique_ptr< T > data)
	Record a const object to the store.
StatusCode	recordNonConst (std::unique_ptr< T > data)
	Record a non-const object to the store.
template<class AUXSTORE>
StatusCode	record (std::unique_ptr< T > data, std::unique_ptr< AUXSTORE > store)
	Record a const object and its auxiliary store to the store.
template<class AUXSTORE>
StatusCode	recordNonConst (std::unique_ptr< T > data, std::unique_ptr< AUXSTORE > store)
	Record a non-const object and its auxiliary store to the store.
template<std::derived_from< DataObject > DOBJ> requires std::convertible_to<DOBJ*, T*>
StatusCode	record (SG::DataObjectSharedPtr< DOBJ > data)
	Record a const shared DataObject to the store.
template<std::derived_from< DataObject > DOBJ> requires std::convertible_to<DOBJ*, T*>
StatusCode	recordNonConst (SG::DataObjectSharedPtr< DOBJ > data)
	Record a non-const shared DataObject to the store.
const_pointer_type	put (std::unique_ptr< T > data, bool returnExisting=false) const
	Record an object to the store.
const_pointer_type	put (std::unique_ptr< const T > data, bool returnExisting=false) const
	Record an object to the store.
const_pointer_type	put (std::unique_ptr< const ConstDataVector< T > > data, bool returnExisting=false) const
	Record an object to the store.
const_pointer_type	put (const EventContext &ctx, std::unique_ptr< const ConstDataVector< T > > data, bool returnExisting=false) const
	Record an object to the store.
const_pointer_type	put (const EventContext &ctx, std::unique_ptr< T > data, bool returnExisting=false) const
	Record an object to the store.
const_pointer_type	put (const EventContext &ctx, std::unique_ptr< const T > data, bool returnExisting=false) const
	Record an object to the store.
template<std::derived_from< DataObject > DOBJ> requires std::convertible_to<DOBJ*, T*>
const_pointer_type	put (SG::DataObjectSharedPtr< DOBJ > data) const
	Record an object to the store.
template<std::derived_from< DataObject > DOBJ> requires std::convertible_to<DOBJ*, T*>
const_pointer_type	put (const EventContext &ctx, SG::DataObjectSharedPtr< DOBJ > data) const
	Record an object to the store.
template<class AUXSTORE>
const_pointer_type	put (std::unique_ptr< T > data, std::unique_ptr< AUXSTORE > auxstore) const
	Record an object and its auxiliary store to the store.
template<class AUXSTORE>
const_pointer_type	put (std::unique_ptr< const T > data, std::unique_ptr< const AUXSTORE > auxstore) const
	Record an object and its auxiliary store to the store.
template<class AUXSTORE>
const_pointer_type	put (const EventContext &ctx, std::unique_ptr< T > data, std::unique_ptr< AUXSTORE > auxstore) const
	Record an object and its auxiliary store to the store.
template<class AUXSTORE>
const_pointer_type	put (const EventContext &ctx, std::unique_ptr< const T > data, std::unique_ptr< const AUXSTORE > auxstore) const
	Record an object and its auxiliary store to the store.
WriteHandle &	operator= (std::unique_ptr< T > data)
	Alternate notation for record.
StatusCode	alias (const WriteHandleKey< T > &key)
	Make an alias.
template<class U>
StatusCode	symLink (const WriteHandleKey< U > &key)
	Make an explicit link.
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.
std::string	toString () const
	Convert to a string representation.

Protected Member Functions
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
pointer_type	checkedCachedPtr ()
	Return the cached pointer directly.
template<class U>
StatusCode	doRecord (U data, bool isConst, bool returnExisting)
	Helper for record.
template<class U>
const_pointer_type	doPut (const EventContext *ctx, U data, bool returnExisting, IProxyDict *&store) const
	Helper for put.
template<class AUXSTORE>
WriteHandle< T >::const_pointer_type	doPut (const EventContext *ctx, std::unique_ptr< T > data, std::unique_ptr< AUXSTORE > auxstore) const
	Helper for recording an object and its auxiliary store to the store.
template<class AUXSTORE>
WriteHandle< T >::const_pointer_type	doPut (const EventContext *ctx, std::unique_ptr< const T > data, std::unique_ptr< const AUXSTORE > auxstore) const
	Helper for recording an object and its auxiliary store to the store.
template<class AUXSTORE>
StatusCode	record (std::unique_ptr< T > data, std::unique_ptr< AUXSTORE > auxstore, bool isConst)
	Record an object and its auxiliary store to the store.
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
SG::DataProxy *	m_lockAuxPending = nullptr
	If non-null, then we need to lock the associated aux store object when we're deleted.
std::unique_ptr< VarHandleKey >	m_ownedKey
	An owned VarHandleKey.
const VarHandleKey *	m_key
	The associated key object.

Detailed Description

template<class T>
class SG::WriteHandle< T >

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

Member Typedef Documentation

const_pointer_type

template<class T>

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

Definition at line 74 of file StoreGate/StoreGate/WriteHandle.h.

const_reference_type

template<class T>

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

Definition at line 76 of file StoreGate/StoreGate/WriteHandle.h.

pointer_type

template<class T>

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

Definition at line 73 of file StoreGate/StoreGate/WriteHandle.h.

reference_type

template<class T>

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

Definition at line 75 of file StoreGate/StoreGate/WriteHandle.h.

Constructor & Destructor Documentation

WriteHandle() [1/11]

template<class T>

SG::WriteHandle< T >::WriteHandle

(

)

Default constructor.

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

WriteHandle() [2/11]

template<class T>

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

WriteHandle() [3/11]

template<class T>

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

WriteHandle() [4/11]

template<class T>

SG::WriteHandle< T >::WriteHandle ( const std::string & sgkey, IProxyDict * sg )

explicit

Constructor specifying the key as a string, with data store.

Parameters

sgkey	StoreGate key of the referenced object.
sg	Data store.

WriteHandle() [5/11]

template<class T>

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

WriteHandle() [6/11]

template<class T>

SG::WriteHandle< T >::WriteHandle ( const WriteHandleKey< T > & key )

explicit

Constructor from a WriteHandleKey.

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.

WriteHandle() [7/11]

template<class T>

SG::WriteHandle< T >::WriteHandle ( const WriteHandleKey< T > & key, const EventContext & ctx )

explicit

Constructor from a WriteHandleKey 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.

WriteHandle() [8/11]

template<class T>

SG::WriteHandle< T >::WriteHandle ( SG::WriteHandleKey< T > && key )

explicitdelete

WriteHandle() [9/11]

template<class T>

SG::WriteHandle< T >::WriteHandle ( SG::WriteHandleKey< T > && key, const EventContext & ctx )

explicitdelete

WriteHandle() [10/11]

template<class T>

SG::WriteHandle< T >::WriteHandle

(

const WriteHandle< T > &

rhs

)

Copy constructor.

WriteHandle() [11/11]

template<class T>

SG::WriteHandle< T >::WriteHandle ( WriteHandle< T > && rhs )

noexcept

Move constructor.

~WriteHandle()

template<class T>

SG::WriteHandle< T >::~WriteHandle

(

)

Destructor.

Lock an aux object if m_lockAuxPending is set.

Member Function Documentation

alias()

template<class T>

StatusCode SG::WriteHandle< 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 (i.e., record should have been called on it).

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 672 of file StoreGate/src/VarHandleBase.cxx.

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

cachedPtr()

template<class T>

pointer_type SG::WriteHandle< T >::cachedPtr

(

)

Return the cached pointer directly; no lookup.

checkedCachedPtr()

template<class T>

pointer_type SG::WriteHandle< T >::checkedCachedPtr ( )

private

Return the cached pointer directly.

If it is null, throw ExcNullWriteHandle.

clid()

CLID SG::VarHandleBase::clid ( ) const

inherited

Return the class ID for the referenced object.

cptr()

template<class T>

const_pointer_type SG::WriteHandle< T >::cptr

(

)

const

Dereference the pointer.

Returns the cached pointer.

doPut() [1/3]

template<class T>

template<class AUXSTORE>

WriteHandle< T >::const_pointer_type SG::WriteHandle< T >::doPut ( const EventContext * ctx, std::unique_ptr< const T > data, std::unique_ptr< const AUXSTORE > auxstore ) const

private

Helper for recording an object and its auxiliary store to the store.

Parameters

ctx	The event context, or nullptr to use the current context.
data	The object to record.
auxstore	Auxiliary store object.

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, and the objects passed in are destroyed.

doPut() [2/3]

template<class T>

template<class AUXSTORE>

WriteHandle< T >::const_pointer_type SG::WriteHandle< T >::doPut ( const EventContext * ctx, std::unique_ptr< T > data, std::unique_ptr< AUXSTORE > auxstore ) const

private

Helper for recording an object and its auxiliary store to the store.

Parameters

ctx	The event context, or nullptr to use the current context.
data	The object to record.
auxstore	Auxiliary store object.

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, and the objects passed in are destroyed.

doPut() [3/3]

template<class T>

template<class U>

const_pointer_type SG::WriteHandle< T >::doPut ( const EventContext * ctx, U data, bool returnExisting, IProxyDict *& store ) const

private

Helper for put.

Parameters

	ctx	The event context, or nullptr to use the current context.
	data	The object to record.
	returnExisting	Allow an existing object.
[out]	store	The store being used.

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, data is destroyed.

doRecord()

template<class T>

template<class U>

StatusCode SG::WriteHandle< T >::doRecord ( U data, bool isConst, bool returnExisting )

private

Helper for record.

Parameters

data	The object to record.
isConst	If true, record the object as const.
returnExisting	Allow an existing object.

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 625 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 931 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 482 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 462 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 436 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 424 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 1155 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 450 of file StoreGate/src/VarHandleBase.cxx.

  {
    return isInitialized();
  }

isValid()

template<class T>

virtual bool SG::WriteHandle< 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::WriteHandle< T >::operator*

(

)

Dereference the pointer.

Returns the cached pointer. Throws ExcNullWriteHandle if null.

operator->()

template<class T>

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

(

)

Dereference the pointer.

Returns the cached pointer. Throws ExcNullWriteHandle if null.

operator=() [1/3]

template<class T>

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

(

const WriteHandle< T > &

rhs

)

Assignment operator.

operator=() [2/3]

template<class T>

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

(

std::unique_ptr< T >

data

)

Alternate notation for record.

Records a non-const object.

Parameters

data	Object to record.

Throws an exception on failure.

operator=() [3/3]

template<class T>

WriteHandle & SG::WriteHandle< T >::operator= ( WriteHandle< T > && rhs )

noexcept

Move operator.

ptr()

template<class T>

pointer_type SG::WriteHandle< T >::ptr

(

)

Dereference the pointer.

Returns the cached pointer.

put() [1/12]

template<class T>

template<std::derived_from< DataObject > DOBJ>
requires std::convertible_to<DOBJ*, T*>

const_pointer_type SG::WriteHandle< T >::put	(	const EventContext &	ctx,
		SG::DataObjectSharedPtr< DOBJ >	data ) const

Record an object to the store.

Parameters

ctx	The event context to use.
data	The object to record.

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. Returns the object placed in the store, or nullptr if there was an error.

The event store takes shared ownership of the object.

put() [2/12]

template<class T>

const_pointer_type SG::WriteHandle< T >::put	(	const EventContext &	ctx,
		std::unique_ptr< const ConstDataVector< T > >	data,
		bool	returnExisting = false ) const

Record an object to the store.

Parameters

ctx	The event context to use.
data	The object to record.
returnExisting	Allow an existing object?

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, data is destroyed.

put() [3/12]

template<class T>

const_pointer_type SG::WriteHandle< T >::put	(	const EventContext &	ctx,
		std::unique_ptr< const T >	data,
		bool	returnExisting = false ) const

Record an object to the store.

Parameters

ctx	The event context to use.
data	The object to record.
returnExisting	Allow an existing object?

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, data is destroyed.

put() [4/12]

template<class T>

template<class AUXSTORE>

const_pointer_type SG::WriteHandle< T >::put	(	const EventContext &	ctx,
		std::unique_ptr< const T >	data,
		std::unique_ptr< const AUXSTORE >	auxstore ) const

Record an object and its auxiliary store to the store.

Parameters

ctx	The event context to use.
data	The object to record.
auxstore	Auxiliary store object.

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, and the objects passed in are destroyed.

Unlike the version taking unique_ptr<T>, this does not alter the store pointer of data.

put() [5/12]

template<class T>

const_pointer_type SG::WriteHandle< T >::put	(	const EventContext &	ctx,
		std::unique_ptr< T >	data,
		bool	returnExisting = false ) const

Record an object to the store.

Parameters

ctx	The event context to use.
data	The object to record.
returnExisting	Allow an existing object?

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, data is destroyed.

put() [6/12]

template<class T>

template<class AUXSTORE>

const_pointer_type SG::WriteHandle< T >::put	(	const EventContext &	ctx,
		std::unique_ptr< T >	data,
		std::unique_ptr< AUXSTORE >	auxstore ) const

Record an object and its auxiliary store to the store.

Parameters

ctx	The event context to use.
data	The object to record.
auxstore	Auxiliary store object.

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, and the objects passed in are destroyed.

put() [7/12]

template<class T>

template<std::derived_from< DataObject > DOBJ>
requires std::convertible_to<DOBJ*, T*>

const_pointer_type SG::WriteHandle< T >::put

(

SG::DataObjectSharedPtr< DOBJ >

data

)

const

Record an object to the store.

Parameters

data	The object to record.

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. Returns the object placed in the store, or nullptr if there was an error.

The event store takes shared ownership of the object.

put() [8/12]

template<class T>

const_pointer_type SG::WriteHandle< T >::put	(	std::unique_ptr< const ConstDataVector< T > >	data,
		bool	returnExisting = false ) const

Record an object to the store.

Parameters

data	The object to record.
returnExisting	Allow an existing object?

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, data is destroyed.

put() [9/12]

template<class T>

const_pointer_type SG::WriteHandle< T >::put	(	std::unique_ptr< const T >	data,
		bool	returnExisting = false ) const

Record an object to the store.

Parameters

data	The object to record.
returnExisting	Allow an existing object?

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, data is destroyed.

put() [10/12]

template<class T>

template<class AUXSTORE>

const_pointer_type SG::WriteHandle< T >::put	(	std::unique_ptr< const T >	data,
		std::unique_ptr< const AUXSTORE >	auxstore ) const

Record an object and its auxiliary store to the store.

Parameters

data	The object to record.
auxstore	Auxiliary store object.

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, and the objects passed in are destroyed.

Unlike the version taking unique_ptr<T>, this does not alter the store pointer of data.

put() [11/12]

template<class T>

const_pointer_type SG::WriteHandle< T >::put	(	std::unique_ptr< T >	data,
		bool	returnExisting = false ) const

Record an object to the store.

Parameters

data	The object to record.
returnExisting	Allow an existing object?

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, data is destroyed.

put() [12/12]

template<class T>

template<class AUXSTORE>

const_pointer_type SG::WriteHandle< T >::put	(	std::unique_ptr< T >	data,
		std::unique_ptr< AUXSTORE >	auxstore ) const

Record an object and its auxiliary store to the store.

Parameters

data	The object to record.
auxstore	Auxiliary store object.

Unlike record(), this does not change the handle object. That means that one will not be able to get the object back by dereferencing the handle. 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, and the objects passed in are destroyed.

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 833 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() [1/4]

template<class T>

template<std::derived_from< DataObject > DOBJ>
requires std::convertible_to<DOBJ*, T*>

StatusCode SG::WriteHandle< T >::record

(

SG::DataObjectSharedPtr< DOBJ >

data

)

Record a const shared DataObject to the store.

Parameters

data	The object to record.

The event store takes shared ownership of the object.

record() [2/4]

template<class T>

StatusCode SG::WriteHandle< T >::record

(

std::unique_ptr< T >

data

)

Record a const object to the store.

Parameters

data	The object to record.

record() [3/4]

template<class T>

template<class AUXSTORE>

StatusCode SG::WriteHandle< T >::record ( std::unique_ptr< T > data, std::unique_ptr< AUXSTORE > auxstore, bool isConst )

private

Record an object and its auxiliary store to the store.

Parameters

data	The object to record.
auxstore	Auxiliary store object.
isConst	If true, record the objects as const.

record() [4/4]

template<class T>

template<class AUXSTORE>

StatusCode SG::WriteHandle< T >::record	(	std::unique_ptr< T >	data,
		std::unique_ptr< AUXSTORE >	store )

Record a const object and its auxiliary store to the store.

Parameters

data	The object to record.
auxstore	Auxiliary store object.

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 760 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;
  }

recordNonConst() [1/3]

template<class T>

template<std::derived_from< DataObject > DOBJ>
requires std::convertible_to<DOBJ*, T*>

StatusCode SG::WriteHandle< T >::recordNonConst

(

SG::DataObjectSharedPtr< DOBJ >

data

)

Record a non-const shared DataObject to the store.

Parameters

data	The object to record.

The event store takes shared ownership of the object.

recordNonConst() [2/3]

template<class T>

StatusCode SG::WriteHandle< T >::recordNonConst

(

std::unique_ptr< T >

data

)

Record a non-const object to the store.

Parameters

data	The object to record.

recordNonConst() [3/3]

template<class T>

template<class AUXSTORE>

StatusCode SG::WriteHandle< T >::recordNonConst	(	std::unique_ptr< T >	data,
		std::unique_ptr< AUXSTORE >	store )

Record a non-const object and its auxiliary store to the store.

Parameters

data	The object to record.
auxstore	Auxiliary store object.

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 600 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 1058 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 636 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 1074 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< Cont_t, dType >, SG::WriteDecorHandle< Cont_t, float >, SG::WriteDecorHandle< Cont_t, SegCov_t >, SG::WriteDecorHandle< Cont_t, SegPars_t >, SG::WriteDecorHandle< Cont_t, std::vector< char > >, SG::WriteDecorHandle< Cont_t, std::vector< ElementLink< xAOD::UncalibratedMeasurementContainer > > >, 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< char > >, SG::WriteDecorHandle< DataVector< xAOD::TrackParticle_v1 >, std::vector< float > >, SG::WriteDecorHandle< DataVector< xAOD::TrackParticle_v1 >, std::vector< int > >, SG::WriteDecorHandle< xAOD::CaloClusterContainer, std::vector< ElementLink< xAOD::CaloClusterContainer > > >, SG::WriteDecorHandle< xAOD::IParticleContainer, float >, SG::WriteDecorHandle< xAOD::IParticleContainer, short >, SG::WriteDecorHandle< xAOD::JetContainer, ElementLink< xAOD::JetContainer > >, SG::WriteDecorHandle< xAOD::JetContainer, float >, and SG::WriteDecorHandle< xAOD::JetContainer, int >.

Definition at line 581 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 517 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 734 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);
    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 708 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 1041 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 406 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 1012 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;
 
      const Atlas::ExtendedEventContext* ectx =
        Atlas::tryGetExtendedEventContext (Gaudi::Hive::currentContext());
 
      return (ectx ? ectx->proxy() : 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()

template<class T>

template<class U>

StatusCode SG::WriteHandle< T >::symLink

(

const WriteHandleKey< U > &

key

)

Make an explicit link.

Parameters

key	Alternate clid by which the referenced object should be known. The SG key must match the key of the current handle.

You should generally not be using this!

The current handle should be valid and referencing an object (i.e., record should have been called on it).

This makes a symlink: the object will be retrievable as a different type.

Note that if T and @U are related via SG_BASE and/or DATAVECTOR_BASE, then you shouldn't need to explicitly make a symlink; that should happen automatically.

If a U* is not convertable to a T* via C++ rules, then you likely will be, at best, relying on undefined behavior. You will probably get warnings from the undefined behavior sanitizer when if you try to dereference the U*.

This usage is here mainly to assist in migrating some existing patterns to MT. You should think several times before using in new code.

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 981 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;
  }

toString()

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

inherited

Convert to a string representation.

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

  {
    std::string s =
      std::format ("VarHandleBase @{} store={}, clid={}, key{}----------- ptr@{}, proxy@{}",
                   static_cast<const void*>(this),
                   store(), clid(), key(),
                   CxxUtils::as_const_ptr (m_ptr),
                   static_cast<const void*>(m_proxy));
    if (m_proxy)
      s += std::format (", DataObject@{}",
                        static_cast<const void*>(m_proxy->object()));
    return s;
  }

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 1095 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 879 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 914 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 653 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 543 of file StoreGate/StoreGate/VarHandleBase.h.

m_lockAuxPending

template<class T>

SG::DataProxy* SG::WriteHandle< T >::m_lockAuxPending = nullptr

private

If non-null, then we need to lock the associated aux store object when we're deleted.

This is set when we record an object along with the associated aux const with the const flag set (the default). Recall that for a const record, we want to support the semantics that you can get a non-const pointer back from the handle as long as it exists, to finish initialization of the object. For an aux store, though, just getting back a non-const pointer is not sufficient, since the store will have been locked at the time of the record, preventing changes to the store.

So if we're meant to record a const aux store object, we don't actually set it const on the record, but instead set this and do the setConst in the destructor.

Definition at line 698 of file StoreGate/StoreGate/WriteHandle.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 538 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 525 of file StoreGate/StoreGate/VarHandleBase.h.

m_ptr

void* SG::VarHandleBase::m_ptr

protectedinherited

The object to which we are bound.

Definition at line 522 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 528 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 531 of file StoreGate/StoreGate/VarHandleBase.h.

---

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

• StoreGate/StoreGate/WriteHandle.h