SG::VarHandleBase Class Reference

Base class for VarHandle types. More...

#include <VarHandleBase.h>

Inherits IResetable.

Inherited by SG::ReadHandle< xAOD::CaloClusterContainer >, SG::ReadHandle< IDC >, SG::ReadHandle< DataVector< xAOD::Electron_v1 > >, SG::ReadHandle< T_Cont >, SG::ReadHandle< DataVector< xAOD::TrackParticle_v1 > >, SG::ReadHandle< McEventCollection >, SG::ReadHandle< DataVector< Trk::Track > >, SG::ReadHandle< SpacePointContainer >, SG::ReadHandle< SpacePointOverlapCollection >, SG::ReadHandle< Trk::PRDtoTrackMap >, SG::ReadHandle< PixelGangedClusterAmbiguities >, SG::ReadHandle< DataVector< IParticle > >, SG::ReadHandle< DataVector< xAOD::Jet_v1 > >, SG::ReadHandle< LVL1::jTowerContainer >, SG::ReadHandle< Cont_t >, SG::ReadHandle< MyDataObj >, SG::ReadHandle< VxContainer >, SG::UpdateHandle< IDCBackend >, SG::WriteHandle< xAOD::CaloClusterContainer >, SG::WriteHandle< CaloClusterCellLinkContainer >, SG::WriteHandle< Cont_t >, SG::WriteHandle< IDC >, SG::WriteHandle< xAOD::AuxiliaryMeasurementContainer >, SG::WriteHandle< xAOD::TrackSurfaceContainer >, SG::WriteHandle< DecisionContainer >, SG::WriteHandle< Muon::MuonPrepDataContainer< MuonPrepDataCollection< PrdType > > >, SG::WriteHandle< HitContainerType >, SG::WriteHandle< AtlasHitsVector< TrackRecord > >, SG::WriteHandle< HGTD_RDO_Container >, SG::WriteHandle< HGTD_ALTIROC_RDO_Container >, SG::WriteHandle< InDetSimDataCollection >, SG::WriteHandle< McEventCollection >, SG::WriteHandle< InDetRawDataContainer< InDetRawDataCollection< SCT_RDORawData > > >, SG::WriteHandle< HijingEventParams >, SG::WriteHandle< InDetRawDataContainer< InDetRawDataCollection< PixelRDORawData > > >, SG::WriteHandle< DataVector< xAOD::CaloRings_v1 > >, SG::WriteHandle< DataVector< xAOD::RingSet_v1 > >, SG::WriteHandle< SG::ThinningDecision >, SG::WriteHandle< InDetRawDataContainer< InDetRawDataCollection< TRT_RDORawData > > >, SG::WriteHandle< TrigRoiDescriptorCollection >, SG::WriteHandle< DataVector< Particle_v1 > >, SG::WriteHandle< DataVector< xAOD::TrigMissingET_v1 > >, SG::WriteHandle< DataVector< TrigComposite_v1 > >, SG::WriteHandle< DataVector< xAOD::Vertex_v1 > >, SG::WriteHandle< xAOD::VertexAuxContainer_v1 >, SG::ReadHandle< T >, SG::TypelessWriteHandle, SG::UpdateHandle< T >, and SG::WriteHandle< T >.

Collaboration diagram for SG::VarHandleBase:

Public Member Functions
	VarHandleBase (CLID clid, Gaudi::DataHandle::Mode mode)
	Constructor with default key.
	VarHandleBase (CLID clid, const std::string &sgkey, Gaudi::DataHandle::Mode mode, const std::string &storename, const EventContext *ctx)
	Constructor with full arguments.
	VarHandleBase (CLID clid, const std::string &sgkey, Gaudi::DataHandle::Mode mode, IProxyDict *sg)
	Constructor given an IProxyDict.
	VarHandleBase (const VarHandleKey &key, const EventContext *ctx)
	Constructor from a VarHandleKey.
	VarHandleBase (SG::DataProxy *proxy, Gaudi::DataHandle::Mode mode)
	Constructor from a DataProxy.
	VarHandleBase (const VarHandleBase &rhs)
	Copy constructor.
	VarHandleBase (VarHandleBase &&rhs) noexcept
	Move constructor.
VarHandleBase &	operator= (const VarHandleBase &rhs)
	Assignment operator.
VarHandleBase &	operator= (VarHandleBase &&rhs) noexcept
	Move operator.
virtual	~VarHandleBase () override
	Destructor.
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.
virtual bool	isValid ()=0
	Can the handle be successfully dereferenced?
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
IProxyDict *	storeFromHandle (const EventContext *ctx) const
	Return the store instance to use.
bool	setStoreFromHandle (const EventContext *ctx)
	Initialize the store pointer from the store handle.
void	resetProxy ()
	Clear the m_proxy field and release the old proxy.
void	setProxy (SG::DataProxy *proxy)
	Set a new proxy.
void *	typeless_dataPointer_fromProxy (SG::DataProxy *proxy, bool quiet) const
	Retrieve a pointer from a proxy.

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

Friends
void	Athena_test::varHandleTest (SGTest::TestStore &)
void	Athena_test::resetableTest (void)
void	Athena_test::refCountTest (void)

Detailed Description

Base class for VarHandle types.

This is the base class for smart pointer types used to access objects in an IProxyDict (such as a StoreGateSvc). The handle types ReadHandle, WriteHandle, and UpdateHandle derive from this; see those classes for usage information.

This class references a VarHandleKey, which holds the CLID of the class we're referencing (which gets passed to the constructor of this class from the templated derived classes), the StoreGate key of the object we're referencing, and a handle to the event store. The key object can be passed to this object via the constructor; otherwise, we create and own a new VarHandleKey object.

In this class, we keep a pointer to the actual event store being used (may be thread-dependent), a pointer to the DataProxy for the referenced object, and a cached pointer to the object itself.

A handle object may be used as a algorithm/tool property directly. Because the handle caches state, however, this means that the component using it cannot be reentrant. In such a case, the handle will be reset when the current algorithm completes. In this case, the handle will be bound to the proxy.

The preferred way of using handles is to use a HandleKey object (one of ReadHandleKey<T>, WriteHandleKey<T>, UpdateHandleKey<T>) as the property, and to create a handle instance on the stack from the key object (and the event context, if available). In this case, the handle will not be bound to the proxy. A handle created in this way should not live beyond the end of the algorithm in which it was created.

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

Constructor & Destructor Documentation

VarHandleBase() [1/7]

SG::VarHandleBase::VarHandleBase ( CLID clid, Gaudi::DataHandle::Mode mode )

explicit

Constructor with default key.

Parameters

clid	CLID of the referenced class.
mode	Mode of this handle (read/write/update).

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

                                                                  :
    IResetable(),
    m_ptr(0),
    m_proxy(0),
    m_store(nullptr),
    m_storeWasSet(false),
    m_ownedKey (std::make_unique<VarHandleKey> (clid, "", mode)),
    m_key (m_ownedKey.get())
  {
    m_ownedKey->setOwningHandle (this);
#ifdef DEBUG_VHB
    dbg::print(stderr, "VarHandleBase() {}\n", dbg::ptr(this));
#endif
  }

VarHandleBase() [2/7]

SG::VarHandleBase::VarHandleBase ( CLID clid, const std::string & sgkey, Gaudi::DataHandle::Mode mode, const std::string & storename, const EventContext * ctx )

explicit

Constructor with full arguments.

Parameters

clid	CLID of the referenced class.
sgkey	StoreGate key of the referenced object.
mode	Mode of this handle (read/write/update).
storename	Name of the referenced event store.
ctx	The event context to use, or nullptr.

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

                                                        :  
    IResetable(),
    m_ptr(NULL),
    m_proxy(NULL),
    m_store(nullptr),
    m_storeWasSet(false),
    m_ownedKey (std::make_unique<VarHandleKey> (clid, sgkey, mode, storename)),
    m_key (m_ownedKey.get())
  {
    m_ownedKey->setOwningHandle (this);
 
    if (ctx && !setStoreFromHandle(ctx)) {
      throw SG::ExcHandleInitError (clid, sgkey, storename);
    }
  }

VarHandleBase() [3/7]

SG::VarHandleBase::VarHandleBase ( CLID clid, const std::string & sgkey, Gaudi::DataHandle::Mode mode, IProxyDict * sg )

explicit

Constructor given an IProxyDict.

Parameters

clid	CLID of the referenced class.
sgkey	StoreGate key of the referenced object.
mode	Mode of this handle (read/write/update).
sg	The referenced store.

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

                                               :
    IResetable(),
    m_ptr(nullptr),
    m_proxy(nullptr),
    m_store(sg),
    m_storeWasSet(true),
    m_ownedKey (std::make_unique<VarHandleKey> (clid, sgkey, mode, sg->name())),
    m_key (m_ownedKey.get())
  {
    m_ownedKey->setOwningHandle (this);
  }

VarHandleBase() [4/7]

SG::VarHandleBase::VarHandleBase ( const VarHandleKey & key, const EventContext * ctx )

explicit

Constructor from a VarHandleKey.

Parameters

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

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 ctx will be used. If ctx is null, then the current event context will be read.

Parameters

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

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

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

    : m_key (&key)
  {
  }

VarHandleBase() [5/7]

SG::VarHandleBase::VarHandleBase ( SG::DataProxy * proxy, Gaudi::DataHandle::Mode mode )

explicit

Constructor from a DataProxy.

Parameters

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

This handle will be bound to the given proxy.

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

    : IResetable(),
      m_ptr (nullptr),
      m_proxy (nullptr),
      m_store (proxy->store()),
      m_storeWasSet (true),
      m_ownedKey (std::make_unique<VarHandleKey> (proxy->clID(),
                                                  proxy->name(),
                                                  mode,
                                                  m_store ? m_store->name() : "")),
      m_key (m_ownedKey.get())
  {
    m_ownedKey->setOwningHandle (this);
    setProxy (proxy);
  }

VarHandleBase() [6/7]

SG::VarHandleBase::VarHandleBase

(

const VarHandleBase &

rhs

)

Copy constructor.

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

                                                         :
    IResetable(),
    m_ptr(rhs.m_ptr),
    m_proxy(nullptr),
    m_store(rhs.m_store),
    m_storeWasSet(rhs.m_storeWasSet)
  {
    if (rhs.m_ownedKey) {
      m_ownedKey = std::make_unique<VarHandleKey> (*rhs.m_ownedKey);
      m_ownedKey->setOwningHandle (this);
      m_key = m_ownedKey.get();
    }
    else {
      m_key = rhs.m_key;
    }
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::copy constr from {} to {} with proxy={} => {}, key={}, store={}\n", dbg::ptr(&rhs), dbg::ptr(this), dbg::proxy(this->m_proxy), dbg::proxy(rhs.m_proxy), this->key(), dbg::store(this->m_store));
#endif
 
    setProxy (rhs.m_proxy);
  }

VarHandleBase() [7/7]

SG::VarHandleBase::VarHandleBase ( VarHandleBase && rhs )

noexcept

Move constructor.

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

                                                             :
    IResetable(),
    m_ptr(rhs.m_ptr),
    m_proxy(nullptr),
    m_store(rhs.m_store),
    m_storeWasSet(rhs.m_storeWasSet),
    m_ownedKey (std::move (rhs.m_ownedKey)),
    m_key (rhs.m_key)
  {
    if (m_ownedKey) {
      m_ownedKey->setOwningHandle (this);
    }
    rhs.m_ptr=0;
 
    if (rhs.m_proxy) {
      if (m_ownedKey) {
        rhs.m_proxy->unbindHandle (&rhs);
        rhs.m_proxy->bindHandle(this);
      }
      m_proxy = rhs.m_proxy;
      rhs.m_proxy=0; //no release: this has the ref now
    }
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::move constr from {} to {} with proxy={}, key={}, store={}\n", dbg::ptr(&rhs), dbg::ptr(this), dbg::proxy(this->m_proxy), this->key(), dbg::store(this->m_store));
#endif
  }

~VarHandleBase()

SG::VarHandleBase::~VarHandleBase ( )

overridevirtual

Destructor.

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

  {
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB:: DESTROY {} with 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
 
    if (m_ownedKey) {
      resetProxy();
    }
    m_ptr = 0;
  }

Member Function Documentation

assign()

StatusCode SG::VarHandleBase::assign

(

const std::string &

sgkey

)

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

clid()

CLID SG::VarHandleBase::clid

(

)

const

Return the class ID for the referenced object.

finalReset()

void SG::VarHandleBase::finalReset ( )

finaloverridevirtual

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

Return the key as a DataObjID.

get_impl()

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

protected

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

)

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

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

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

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

protected

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

finaloverridevirtual

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

virtual bool SG::VarHandleBase::isValid ( )

pure virtual

Can the handle be successfully dereferenced?

Non-const method; the handle may cache information as a result of this.

Implemented in SG::ReadHandle< T >, SG::ReadHandle< Cont_t >, SG::ReadHandle< DataVector< IParticle > >, SG::ReadHandle< DataVector< Trk::Track > >, SG::ReadHandle< DataVector< xAOD::Electron_v1 > >, SG::ReadHandle< DataVector< xAOD::Jet_v1 > >, SG::ReadHandle< DataVector< xAOD::TrackParticle_v1 > >, SG::ReadHandle< IDC >, SG::ReadHandle< LVL1::jTowerContainer >, SG::ReadHandle< McEventCollection >, SG::ReadHandle< MyDataObj >, SG::ReadHandle< PixelGangedClusterAmbiguities >, SG::ReadHandle< SpacePointContainer >, SG::ReadHandle< SpacePointOverlapCollection >, SG::ReadHandle< T_Cont >, SG::ReadHandle< Trk::PRDtoTrackMap >, SG::ReadHandle< VxContainer >, SG::ReadHandle< xAOD::CaloClusterContainer >, SG::TypelessWriteHandle, SG::UpdateHandle< T >, SG::UpdateHandle< IDCBackend >, SG::WriteHandle< T >, SG::WriteHandle< AtlasHitsVector< TrackRecord > >, SG::WriteHandle< CaloClusterCellLinkContainer >, SG::WriteHandle< Cont_t >, SG::WriteHandle< DataVector< Particle_v1 > >, SG::WriteHandle< DataVector< TrigComposite_v1 > >, SG::WriteHandle< DataVector< xAOD::CaloRings_v1 > >, SG::WriteHandle< DataVector< xAOD::RingSet_v1 > >, SG::WriteHandle< DataVector< xAOD::TrigMissingET_v1 > >, SG::WriteHandle< DataVector< xAOD::Vertex_v1 > >, SG::WriteHandle< DecisionContainer >, SG::WriteHandle< HGTD_ALTIROC_RDO_Container >, SG::WriteHandle< HGTD_RDO_Container >, SG::WriteHandle< HijingEventParams >, SG::WriteHandle< HitContainerType >, SG::WriteHandle< IDC >, SG::WriteHandle< InDetRawDataContainer< InDetRawDataCollection< PixelRDORawData > > >, SG::WriteHandle< InDetRawDataContainer< InDetRawDataCollection< SCT_RDORawData > > >, SG::WriteHandle< InDetRawDataContainer< InDetRawDataCollection< TRT_RDORawData > > >, SG::WriteHandle< InDetSimDataCollection >, SG::WriteHandle< McEventCollection >, SG::WriteHandle< Muon::MuonPrepDataContainer< MuonPrepDataCollection< PrdType > > >, SG::WriteHandle< SG::ThinningDecision >, SG::WriteHandle< TrigRoiDescriptorCollection >, SG::WriteHandle< xAOD::AuxiliaryMeasurementContainer >, SG::WriteHandle< xAOD::CaloClusterContainer >, SG::WriteHandle< xAOD::TrackSurfaceContainer >, and SG::WriteHandle< xAOD::VertexAuxContainer_v1 >.

key()

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

finaloverridevirtual

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

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

name()

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

(

)

const

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

Return the key string of the underlying DataObjID.

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

operator=() [1/2]

VarHandleBase & SG::VarHandleBase::operator=

(

const VarHandleBase &

rhs

)

Assignment operator.

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

  {
    if (this != &rhs) {
      if (rhs.m_ownedKey) {
        m_ownedKey = std::make_unique<VarHandleKey> (*rhs.m_ownedKey);
        m_ownedKey->setOwningHandle (this);
        m_key = m_ownedKey.get();
      }
      else {
        m_key = rhs.m_key;
        m_ownedKey.reset();
      }
 
      m_ptr =    rhs.m_ptr;
      m_store =  rhs.m_store;
      m_storeWasSet = rhs.m_storeWasSet;
      setProxy (rhs.m_proxy);
    }
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB::assignment from {} to {} with proxy={}, key={}, store={}\n", dbg::ptr(&rhs), dbg::ptr(this), dbg::proxy(this->m_proxy), this->key(), dbg::store(this->m_store));
#endif
    return *this;
  }

operator=() [2/2]

VarHandleBase & SG::VarHandleBase::operator= ( VarHandleBase && rhs )

noexcept

Move operator.

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

  {
    if (this != &rhs) {
      m_ownedKey = std::move (rhs.m_ownedKey);
      if (m_ownedKey) {
        m_ownedKey->setOwningHandle (this);
      }
      m_key = rhs.m_key;
 
      m_ptr =    rhs.m_ptr;
      m_store =  rhs.m_store;
      m_storeWasSet = rhs.m_storeWasSet;
 
      rhs.m_ptr=0;
 
      resetProxy();
      if (rhs.m_proxy) {
        if (m_ownedKey) {
          rhs.m_proxy->unbindHandle (&rhs);
          rhs.m_proxy->bindHandle (this);
        }
        m_proxy =  rhs.m_proxy;
        rhs.m_proxy=0; //no release: this has the ref now
      }
    }
#ifdef DEBUG_VHB
    dbg::print(stderr, "::VHB:: move assign from {} to {} with proxy={}, key={}, store={}\n", dbg::ptr(&rhs), dbg::ptr(this), dbg::proxy(this->m_proxy), this->key(), dbg::store(this->m_store));
#endif
    return *this;
  }

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

protected

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

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

protected

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

reset()

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

overridevirtual

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

private

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

(

)

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 )

private

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 )

virtual

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 >, char >, 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

(

)

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 )

protected

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 )

protected

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 )

private

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

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

private

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

Return handle to the referenced store.

symLink_impl()

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

protected

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

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

protected

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 )

protected

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

private

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 )

protected

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 )

protected

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

(

)

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

Friends And Related Symbol Documentation

Athena_test::refCountTest

void Athena_test::refCountTest ( void )

friend

Athena_test::resetableTest

void Athena_test::resetableTest ( void )

friend

Athena_test::varHandleTest

void Athena_test::varHandleTest ( SGTest::TestStore & )

friend

Member Data Documentation

m_key

const VarHandleKey* SG::VarHandleBase::m_key

private

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_ownedKey

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

private

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

protected

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

protected

The object to which we are bound.

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

m_store

IProxyDict* SG::VarHandleBase::m_store

protected

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

protected

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 files:

• StoreGate/StoreGate/VarHandleBase.h
• AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx
• StoreGate/src/VarHandleBase.cxx