xAOD::THolder Class Reference

This class takes care of holding EDM objects in memory. More...

#include <THolder.h>

Inheritance diagram for xAOD::THolder:

Collaboration diagram for xAOD::THolder:

Public Types
enum	TypeKind { OTHER , DATAVECTOR , AUXELEMENT }
	Type of the object held by this one. More...

Public Member Functions
	THolder ()
	Default constructor.
	THolder (void *object, ::TClass *type, ::Bool_t owner=kTRUE)
	Constructor pointing to an object in memory.
	THolder (void *object, const std::type_info &type, ::Bool_t owner=kTRUE)
	Constructor pointing to an object in memory.
	THolder (const void *object, ::TClass *type, ::Bool_t owner=kTRUE)
	Constructor pointing to a const object in memory.
	THolder (const void *object, const std::type_info &type, ::Bool_t owner=kTRUE)
	Constructor pointing to a const object in memory.
	THolder (const THolder &parent)
	Copy constructor.
	THolder (THolder &&parent)
	Move constructor.
virtual	~THolder ()
	The destructor cleans out the memory used by the managed object.
THolder &	operator= (const THolder &rhs)
	Assignment operator.
THolder &	operator= (THolder &&rhs)
	Move operator.
const void *	get () const
	Return a typeless const pointer to the held object.
void *	get ()
	Return a typeless pointer to the held object.
void **	getPtr ()
	Return a typeless pointer to the held object's pointer.
virtual void	set (void *obj)
	Replace the managed object.
::Bool_t	isOwner () const
	Check whether the holder owns its object.
void	setOwner (::Bool_t state=kTRUE)
	Set whether the holder should own its object.
::Bool_t	isConst () const
	Check if the object is const.
void	setConst ()
	Mark the object as const.
virtual void *	getAs (const std::type_info &tid, ::Bool_t silent=kFALSE) const
	Return the object as a specific pointer.
virtual const void *	getAsConst (const std::type_info &tid, ::Bool_t silent=kFALSE) const
	Return the object as a specific, constant pointer.
void	renew ()
	Renew the object in memory.
TypeKind	typeKind () const
	Return the type of the object held by this one.
const ::TClass *	getClass () const
::TClass *	getClass ()
const std::type_info *	getTypeInfo () const

Protected Member Functions
void	deleteObject ()
	Internal function used to delete the managed object from memory.
void *	getImpl (const std::type_info &tid, ::Bool_t silent=kFALSE) const
	Internal function to get an object.

Protected Attributes
void *	m_object
	Typeless pointer to the object in memory.
::TClass *	m_type
	Concrete type of the object being held on to.
const std::type_info *	m_typeInfo
	Concrete type of the object, if it doesn't have a dictionary.
::Bool_t	m_owner
	A flag for whether the object owns what it points to.
TypeKind	m_typeKind
	Type of the object held.
::Bool_t	m_const
	Is the held object const?

Detailed Description

This class takes care of holding EDM objects in memory.

In order to be able to access EDM objects easily as their concrete type, or as one of their base classes, a little trickery is needed.

We always access the branches of the input TTree as their concrete, transient types. It is then up to our own code to decide if the user is requesting the object as a type that it can be cast to, or not.

Author

Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Definition at line 35 of file THolder.h.

Member Enumeration Documentation

TypeKind

enum xAOD::THolder::TypeKind

Type of the object held by this one.

Enumerator
OTHER	Some non-specified type.
DATAVECTOR	A DataVector container.
AUXELEMENT	A type inheriting from SG::AuxElement.

Definition at line 103 of file THolder.h.

                    {
        OTHER,      
        DATAVECTOR, 
        AUXELEMENT  
      }; // enum TypeKind

Constructor & Destructor Documentation

THolder() [1/7]

xAOD::THolder::THolder

(

)

Default constructor.

Definition at line 54 of file THolder.cxx.

      : m_object( 0 ), m_type( 0 ), m_typeInfo( 0 ), m_owner( kFALSE ),
        m_typeKind( OTHER ), m_const( kFALSE ) {
 
   }

THolder() [2/7]

xAOD::THolder::THolder	(	void *	object,
		::TClass *	type,
		::Bool_t	owner = kTRUE )

Constructor pointing to an object in memory.

Definition at line 60 of file THolder.cxx.

      : m_object( object ), m_type( type ),
        m_typeInfo( m_type ? m_type->GetTypeInfo() : 0 ), m_owner( owner ),
        m_typeKind( getTypeKind( type ) ), m_const( kFALSE ) {
 
      // Complain if the passed dictionary will be unusable later on:
      if( m_type && ( ! m_type->IsLoaded() ) ) {
         ::Warning( "xAOD::THolder::THolder", "Received an emulated dictionary "
                    "for type: %s", m_type->GetName() );
      }
 
      // Increase the object count:
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
   }

THolder() [3/7]

xAOD::THolder::THolder	(	void *	object,
		const std::type_info &	type,
		::Bool_t	owner = kTRUE )

Constructor pointing to an object in memory.

Definition at line 77 of file THolder.cxx.

      : m_object( object ), m_type( 0 ), m_typeInfo( &type ), m_owner( owner ),
        m_typeKind( OTHER ), m_const( kFALSE ) {
 
      // Increase the object count:
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
   }

THolder() [4/7]

xAOD::THolder::THolder	(	const void *	object,
		::TClass *	type,
		::Bool_t	owner = kTRUE )

Constructor pointing to a const object in memory.

Definition at line 87 of file THolder.cxx.

      : THolder( safe_const_cast(object), type, owner ) {
 
      m_const = kTRUE;
   }

THolder() [5/7]

xAOD::THolder::THolder	(	const void *	object,
		const std::type_info &	type,
		::Bool_t	owner = kTRUE )

Constructor pointing to a const object in memory.

Definition at line 93 of file THolder.cxx.

      : THolder( safe_const_cast(object), type, owner ) {
 
      m_const = kTRUE;
   }

THolder() [6/7]

xAOD::THolder::THolder

(

const THolder &

parent

)

Copy constructor.

The copy constructor takes the pointer from the parent object, and based on whether the parent owned the object or not, increments the shared count.

Parameters

parent

The parent object that should be copied

Definition at line 105 of file THolder.cxx.

      : m_object( parent.m_object ), m_type( parent.m_type ),
        m_typeInfo( parent.m_typeInfo ), m_owner( parent.m_owner ),
        m_typeKind( parent.m_typeKind ), m_const( parent.m_const ) {
 
      // Increase the object count:
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
   }

THolder() [7/7]

xAOD::THolder::THolder

(

THolder &&

parent

)

Move constructor.

This is a tricky one.

Since the object is being moved, meaning that the parent will be deleted right after this operation, instead of incrementing and then decrementing the shared count, we just tell the parent that it doesn't own its object anymore. In this case if it did own it, the shared count will remain valid. Since it's this object owning it now. If it didn't own the object in the first place, then no hard no foul.

Parameters

parent

The parent object that should be moved

Definition at line 126 of file THolder.cxx.

      : m_object( parent.m_object ), m_type( parent.m_type ),
        m_typeInfo( parent.m_typeInfo ), m_owner( parent.m_owner ),
        m_typeKind( parent.m_typeKind ), m_const( parent.m_const ) {
 
      // Tell the parent that it no longer owns the object:
      parent.m_owner = kFALSE;
   }

~THolder()

xAOD::THolder::~THolder ( )

virtual

The destructor cleans out the memory used by the managed object.

Definition at line 136 of file THolder.cxx.

                     {
 
      // Delete the object using its dictionary:
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         deleteObject();
      }
   }

Member Function Documentation

deleteObject()

void xAOD::THolder::deleteObject ( )

protected

Internal function used to delete the managed object from memory.

Definition at line 438 of file THolder.cxx.

                              {
 
      // Check if we even have an object:
      if( ! m_object ) {
         return;
      }
 
      // Delete the object then:
      if( m_type ) {
         if( m_type->IsLoaded() ) {
            m_type->Destructor( m_object );
         }
         // In certain situations it can happen that the memory cleanup for a
         // particular TEvent object happens after ROOT already started to
         // unload libraries from memory. In this case, since the application
         // is anyway on its final leg, let's not bother the user with
         // additional warnings about not being able to clean up after the
         // managed object.
      } else if( m_typeInfo ) {
         const TVirtualDestructor* d =
            TDestructorRegistry::instance().get( *m_typeInfo );
         if( d ) {
            d->destruct( m_object );
         } else {
            ::Error( "xAOD::THolder::deleteObject",
                     XAOD_MESSAGE( "Couldn't delete managed object" ) );
         }
      } else {
         ::Error( "xAOD::THolder::deleteObject",
                  XAOD_MESSAGE( "Couldn't delete managed object" ) );
      }
 
      return;
   }

get() [1/2]

void * xAOD::THolder::get

(

)

Return a typeless pointer to the held object.

Definition at line 221 of file THolder.cxx.

                      {
 
      return m_object;
   }

get() [2/2]

const void * xAOD::THolder::get

(

)

const

Return a typeless const pointer to the held object.

Definition at line 216 of file THolder.cxx.

                                  {
 
      return m_object;
   }

getAs()

void * xAOD::THolder::getAs ( const std::type_info & tid, ::Bool_t silent = kFALSE ) const

virtual

Return the object as a specific pointer.

This function is used for retrieving an object as one of its bases.

It is used when the caller requires a non-const pointer to the managed object.

Parameters

tid	The type as which the object is to be retrieved
silent	When kTRUE, the call will fail silently when unsuccessful

Returns

A non-const pointer that can be cast to the requested type

Reimplemented in xAOD::TCDVHolderT< T >.

Definition at line 371 of file THolder.cxx.

                                               {
 
      if( m_const ) {
         if( ! silent ) {
            ::Warning( "xAOD::THolder::getAs",
                       "Trying to retrieve const \"%s\" via non-const pointer \"%s\"",
                       m_type->GetName(),
                       SG::normalizedTypeinfoName( tid ).c_str() );
         }
         return nullptr;
      }
      return getImpl( tid, silent );
   }

getAsConst()

const void * xAOD::THolder::getAsConst ( const std::type_info & tid, ::Bool_t silent = kFALSE ) const

virtual

Return the object as a specific, constant pointer.

This function is used for retrieving an object as one of its bases.

It is used when the caller need a const pointer to the managed object.

Parameters

tid	The type as which the object is to be retrieved
silent	When kTRUE, the call will fail silently when unsuccessful

Returns

A const pointer that can be cast to the requested type

Reimplemented in xAOD::TCDVHolderT< T >.

Definition at line 395 of file THolder.cxx.

                                                          {
 
      // In the generic case we just forward this call:
      return getImpl( tid, silent );
   }

getClass() [1/2]

TClass * xAOD::THolder::getClass

(

)

Definition at line 407 of file THolder.cxx.

                             {
 
      return m_type;
   }

getClass() [2/2]

const::TClass * xAOD::THolder::getClass

(

)

const

Return the concrete type of the object

Definition at line 402 of file THolder.cxx.

                                         {
 
      return m_type;
   }

getImpl()

void * xAOD::THolder::getImpl ( const std::type_info & tid, ::Bool_t silent = kFALSE ) const

protected

Internal function to get an object.

Internal helper or getAs and getAsConst.

Parameters

tid	The type as which the object is to be retrieved
silent	When kTRUE, the call will fail silently when unsuccessful

Returns

A pointer that can be cast to the requested type

Definition at line 297 of file THolder.cxx.

                                                 {
 
      // If there is no dictionary for the object, then the logic is pretty
      // simple:
      if( ! m_type ) {
         // Check if the user asked for the right type. Remember that in this
         // case we can't return an object as its base type.
         if( tid != *m_typeInfo ) {
            if( ! silent ) {
               const std::string heldType =
                  SG::normalizedTypeinfoName( *m_typeInfo );
               const std::string reqType =
                  SG::normalizedTypeinfoName( tid );
               ::Warning( "xAOD::THolder::getAs",
                          "Trying to retrieve %s object with a %s pointer",
                          heldType.c_str(), reqType.c_str() );
            }
            return 0;
         }
         // The user did ask for the correct type:
         return m_object;
      }
 
      // Check if we already know about this type:
      auto userClass = Internal::THolderCache::instance().getClass( tid );
      // If not, look for it now:
      if( ! userClass.first ) {
         userClass.second = ::TClass::GetClass( tid );
         Internal::THolderCache::instance().addClass( tid, userClass.second );
      }
 
      // If we still don't have a dictionary, that's an issue:
      if( ! userClass.second ) {
         if( ! silent ) {
            ::Error( "xAOD::THolder::getAs",
                     XAOD_MESSAGE( "Couldn't access the dictionary for user "
                                   "type: %s" ),
                     SG::normalizedTypeinfoName( tid ).c_str() );
         }
         return 0;
      }
 
      // Check if the user requested a valid base class for the held type.
      //
      // Calling GetBaseClassOffset is in general not thread-safe as it could
      // trigger the loading and parsing of StreamerInfo. However, we assume
      // that this has already been done once we get here.
      TClass* cl ATLAS_THREAD_SAFE = m_type;
      const Int_t offset = cl->GetBaseClassOffset( userClass.second );
      if( offset < 0 ) {
         if( ! silent ) {
            ::Warning( "xAOD::THolder::getAs",
                       "User class \"%s\" is not a valid base "
                       "of \"%s\"",
                       SG::normalizedTypeinfoName( tid ).c_str(),
                       m_type->GetName() );
         }
         return 0;
      }
 
      // If all is fine, do the cast:
      return ( static_cast< char* >( m_object ) + offset );
   }

getPtr()

void ** xAOD::THolder::getPtr

(

)

Return a typeless pointer to the held object's pointer.

Definition at line 226 of file THolder.cxx.

                          {
 
      return &m_object;
   }

getTypeInfo()

const std::type_info * xAOD::THolder::getTypeInfo

(

)

const

Definition at line 412 of file THolder.cxx.

                                                  {
 
      return m_typeInfo;
   }

isConst()

Bool_t xAOD::THolder::isConst

(

)

const

Check if the object is const.

Definition at line 280 of file THolder.cxx.

                                 {
 
      return m_const;
   }

isOwner()

Bool_t xAOD::THolder::isOwner

(

)

const

Check whether the holder owns its object.

Definition at line 253 of file THolder.cxx.

                                 {
 
      return m_owner;
   }

operator=() [1/2]

THolder & xAOD::THolder::operator=

(

const THolder &

rhs

)

Assignment operator.

The copy operator, just like the copy constructor makes the object aware that it doesn't own the object that it has the pointer to.

Parameters

rhs	The object that has to be copied

Returns

A reference to this same object

Definition at line 151 of file THolder.cxx.

                                                   {
 
      // Check if we need to do anything:
      if( &rhs == this ) return *this;
 
      // Clean up the previously managed object:
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         deleteObject();
      }
 
      // Do the copy:
      m_object   = rhs.m_object;
      m_type     = rhs.m_type;
      m_typeInfo = rhs.m_typeInfo;
      m_owner    = rhs.m_owner;
      m_typeKind = rhs.m_typeKind;
      m_const    = rhs.m_const;
 
      // Increase the object count:
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
 
      // Return this same object:
      return *this;
   }

operator=() [2/2]

THolder & xAOD::THolder::operator=

(

THolder &&

rhs

)

Move operator.

This move operator is necessary to be able to use this type as a value type of STL containers.

See the comments given for the move constructor for an explanation of the behaviour of this operator.

Parameters

rhs	The object that has to be moved

Returns

A reference to this same object

Definition at line 188 of file THolder.cxx.

                                              {
 
      // Check if we need to do anything:
      if( &rhs == this ) return *this;
 
      // Clean up the previously managed object:
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         deleteObject();
      }
 
      // Do the copy:
      m_object   = rhs.m_object;
      m_type     = rhs.m_type;
      m_typeInfo = rhs.m_typeInfo;
      m_owner    = rhs.m_owner;
      m_typeKind = rhs.m_typeKind;
      m_const    = rhs.m_const;
 
      // Instead of doing anything with the shared count here, just make the
      // parent not own the object anymore. The logic is the same as discussed
      // in the move constructor.
      rhs.m_owner = kFALSE;
 
      // Return this same object:
      return *this;
   }

renew()

void xAOD::THolder::renew

(

)

Renew the object in memory.

This function is mostly used in "Athena access mode", to delete the managed objects from memory between events, and recreate them from scratch.

Definition at line 421 of file THolder.cxx.

                       {
 
      // Delete the object using its dictionary:
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         deleteObject();
      }
 
      // Create a new object:
      m_owner = kTRUE;
      m_object = m_type->New();
      Internal::THolderCache::instance().incRef( m_object );
 
      // Return gracefuly:
      return;
   }

set()

void xAOD::THolder::set ( void * obj )

virtual

Replace the managed object.

Reimplemented in xAOD::TCDVHolderT< T >.

Definition at line 231 of file THolder.cxx.

                                {
 
      // Check if we need to do anything:
      if( m_object == obj ) return;
 
      // Delete the previous object:
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         deleteObject();
      }
 
      // Hold on to the new object from now on:
      m_object = obj;
 
      // Increase the object count:
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
 
      return;
   }

setConst()

void xAOD::THolder::setConst

(

)

Mark the object as const.

Definition at line 285 of file THolder.cxx.

                          {
 
      m_const = kTRUE;
   }

setOwner()

void xAOD::THolder::setOwner

(

::Bool_t

state = kTRUE

)

Set whether the holder should own its object.

Definition at line 258 of file THolder.cxx.

                                        {
 
      // Check if anything needs to be done:
      if( state == m_owner ) return;
 
      if( m_object && m_owner &&
          ( ! Internal::THolderCache::instance().decRef( m_object ) ) ) {
         ::Warning( "xAOD::THolder::setOwner",
                    "Deleting object %p no longer held by any owner",
                    m_object );
         deleteObject();
      }
 
      m_owner = state;
 
      if( m_object && m_owner ) {
         Internal::THolderCache::instance().incRef( m_object );
      }
 
      return;
   }

typeKind()

TypeKind xAOD::THolder::typeKind ( ) const

inline

Return the type of the object held by this one.

Definition at line 110 of file THolder.h.

                                {
         return m_typeKind;
      }

Member Data Documentation

m_const

::Bool_t xAOD::THolder::m_const

protected

Is the held object const?

Definition at line 133 of file THolder.h.

m_object

void* xAOD::THolder::m_object

protected

Typeless pointer to the object in memory.

Definition at line 123 of file THolder.h.

m_owner

::Bool_t xAOD::THolder::m_owner

protected

A flag for whether the object owns what it points to.

Definition at line 129 of file THolder.h.

m_type

::TClass* xAOD::THolder::m_type

protected

Concrete type of the object being held on to.

Definition at line 125 of file THolder.h.

m_typeInfo

const std::type_info* xAOD::THolder::m_typeInfo

protected

Concrete type of the object, if it doesn't have a dictionary.

Definition at line 127 of file THolder.h.

m_typeKind

TypeKind xAOD::THolder::m_typeKind

protected

Type of the object held.

Definition at line 131 of file THolder.h.

---

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

• THolder.h
• THolder.cxx