xAODPrivate::HolderBucket Class Reference

Helper object for holding something through a THolder. More...

Inheritance diagram for xAODPrivate::HolderBucket:

Collaboration diagram for xAODPrivate::HolderBucket:

Public Member Functions
	HolderBucket (const std::string &key, const std::type_info &ti, xAOD::Event &event)
	Constructor with an existing holder.
void *	object () override
	Return the object held.
const std::type_info &	tinfo () const override
	Return the type_info of the stored object.
void *	cast (CLID, SG::IRegisterTransient *, bool) override
	Return the object, cast to a CLID's type.
void *	cast (const std::type_info &tinfo, SG::IRegisterTransient *, bool isConst) override
	Return the object, cast to a certain type.
void *	cast (CLID, const std::type_info &tinfo, SG::IRegisterTransient *irt, bool isConst) override
	Return the object, cast to type.
void	relinquish () override
	Give up ownership of the bucket's contents. A no-op.
void	lock () override
	Lock the held object. A no-op.
template<class T>
T *	cast (SG::IRegisterTransient *irt=0, bool isConst=true)
	Return the contents of the DataBucket, converted to type T.

Private Attributes
const std::string	m_key
	The key of the object.
const std::type_info &	m_ti
	The type info of the object.
xAOD::Event &	m_event
	The original Event object.

Detailed Description

Helper object for holding something through a THolder.

Definition at line 42 of file EventIProxyDict.cxx.

Constructor & Destructor Documentation

HolderBucket()

xAODPrivate::HolderBucket::HolderBucket ( const std::string & key, const std::type_info & ti, xAOD::Event & event )

inline

Constructor with an existing holder.

Definition at line 46 of file EventIProxyDict.cxx.

      : m_key(key), m_ti(ti), m_event(event) {}

Member Function Documentation

cast() [1/4]

template<class T>

T * DataBucketBase::cast ( SG::IRegisterTransient * irt = 0, bool isConst = true )

inherited

Return the contents of the DataBucket, converted to type T.

Note that only derived->base conversions are allowed here. T must have a valid Class ID for this to work.

Parameters

irt	To be called if we make a new instance.
isConst	True if the object being converted is regarded as const.

cast() [2/4]

void * xAODPrivate::HolderBucket::cast ( CLID , const std::type_info & tinfo, SG::IRegisterTransient * irt, bool isConst )

inlineoverridevirtual

Return the object, cast to type.

Reimplemented from DataBucketBase.

Definition at line 122 of file EventIProxyDict.cxx.

                                    {
    return HolderBucket::cast(tinfo, irt, isConst);
  }

cast() [3/4]

void * xAODPrivate::HolderBucket::cast ( CLID , SG::IRegisterTransient * , bool  )

inlineoverridevirtual

Return the object, cast to a CLID's type.

Implements DataBucketBase.

Definition at line 81 of file EventIProxyDict.cxx.

                                                         {
 
    throw std::runtime_error("xAODPrivate::HolderBucket::cast not implemented");
    return 0;
  }

cast() [4/4]

void * xAODPrivate::HolderBucket::cast ( const std::type_info & tinfo, SG::IRegisterTransient * , bool isConst )

inlineoverridevirtual

Return the object, cast to a certain type.

Implements DataBucketBase.

Definition at line 88 of file EventIProxyDict.cxx.

                                    {
 
    // Do the cast:
    static constexpr bool SILENT = true;
    static constexpr bool METADATA = false;
    const void* result = nullptr;
    if (isConst == false) {
      // Just look among the outputs.
      result = m_event.getOutputObject(m_key, tinfo, METADATA);
    } else {
      // Look among the output objects first:
      result = m_event.getOutputObject(m_key, tinfo, METADATA);
      // Check if it succeeded:
      if (result == nullptr) {
        // Try the input then:
        result = m_event.getInputObject(m_key, tinfo, SILENT, METADATA);
      } else {
        // Even if there is an output object with this key, it may
        // be an input object that was copied to the output. So let's
        // try to silently retrieve an input object as well. This makes
        // sure that the input/output object is updated for the current
        // event.
        m_event.getInputObject(m_key, tinfo, SILENT, METADATA);
      }
    }
 
    // Return the pointer:
    void* nc_result ATLAS_THREAD_SAFE =
        const_cast<void*>(result);  // DataBucketBase interface
    return nc_result;
  }

lock()

void xAODPrivate::HolderBucket::lock ( )

inlineoverridevirtual

Lock the held object. A no-op.

Implements DataBucketBase.

Definition at line 130 of file EventIProxyDict.cxx.

{}

object()

void * xAODPrivate::HolderBucket::object ( )

inlineoverridevirtual

Return the object held.

Implements DataBucketBase.

Definition at line 51 of file EventIProxyDict.cxx.

                          {
 
    // Look among the output objects first:
    static constexpr bool METADATA = false;
    const void* result = m_event.getOutputObject(m_key, m_ti, METADATA);
    // Check if it succeeded:
    static constexpr bool SILENT = false;
    if (!result) {
      // Try the input then:
      result = m_event.getInputObject(m_key, m_ti, SILENT, METADATA);
    } else {
      // Even if there is an output object with this key, it may
      // be an input object that was copied to the output. So let's
      // try to silently retrieve an input object as well. This makes
      // sure that the input/output object is updated for the current
      // event.
      static constexpr bool SILENT = false;
      m_event.getInputObject(m_key, m_ti, SILENT, METADATA);
    }
 
    // Return the pointer:
    void* nc_result ATLAS_THREAD_SAFE =
        const_cast<void*>(result);  // DataBucketBase interface
    return nc_result;
  }

relinquish()

void xAODPrivate::HolderBucket::relinquish ( )

inlineoverridevirtual

Give up ownership of the bucket's contents. A no-op.

Implements DataBucketBase.

Definition at line 128 of file EventIProxyDict.cxx.

{}

tinfo()

const std::type_info & xAODPrivate::HolderBucket::tinfo ( ) const

inlineoverridevirtual

Return the type_info of the stored object.

Implements DataBucketBase.

Definition at line 78 of file EventIProxyDict.cxx.

{ return m_ti; }

Member Data Documentation

m_event

xAOD::Event& xAODPrivate::HolderBucket::m_event

private

The original Event object.

Definition at line 138 of file EventIProxyDict.cxx.

m_key

const std::string xAODPrivate::HolderBucket::m_key

private

The key of the object.

Definition at line 134 of file EventIProxyDict.cxx.

m_ti

const std::type_info& xAODPrivate::HolderBucket::m_ti

private

The type info of the object.

Definition at line 136 of file EventIProxyDict.cxx.

---

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

• EventIProxyDict.cxx