xAOD::TStore Class Reference

A relatively simple transient store for objects created in analysis. More...

#include <TStore.h>

Inheritance diagram for xAOD::TStore:

Collaboration diagram for xAOD::TStore:

Public Member Functions
	TStore ()
	Default constructor. More...
	TStore (const TStore &)=delete
	Disallow copying the object. More...
virtual	~TStore ()
	Destructor. More...
TStore &	operator= (const TStore &)=delete
	Disallow copying the object. More...
void	setActive ()
	Set this as the active transient store in the application. More...
void	print () const
	Print the current contents of the transient store. More...

Protected Types
typedef std::map< std::string, THolder * >	Objects_t
	Type of the internal container storing all the objects. More...
typedef SG::SGKeyMap< std::string >	HashedKeys_t
	Type of the internal storage for the hashed keys of the object names. More...

Protected Member Functions
::Bool_t	contains (const std::string &key, const std::type_info &ti) const
	Non-templated function implementing the containment check. More...
::Bool_t	isConst (const std::string &key, const std::type_info &ti) const
	Non-templated function implementing the const-ness check. More...
void *	getObject (const std::string &key, const std::type_info &ti) const
	Function retrieving a non-const object in a non-template way. More...
const void *	getConstObject (const std::string &key, const std::type_info &ti) const
	Function retrieving a const object in a non-template way. More...
StatusCode	record (void *obj, const std::string &key, const std::string &classname, ::Bool_t isOwner, ::Bool_t isConst)
	Function recording an object that has a dictionary available. More...
StatusCode	record (void *obj, const std::string &key, const std::type_info &ti, ::Bool_t isOwner, ::Bool_t isConst)
	Function recording an object that has no dictionary. More...
template<class T >
StatusCode	record (ConstDataVector< T > *obj, const std::string &key, const std::type_info &ti, ::Bool_t isOwner, ::Bool_t isConst)
	Function doing the first step of recording a ConstDataVector object. More...
StatusCode	record (THolder *hldr, const std::string &key)
	Function doing the second step of recording a ConstDataVector object. More...

Protected Attributes
Objects_t	m_objects
	The object storage. More...
HashedKeys_t	m_keys
	The key map. More...

Private Member Functions
template<typename T >
StatusCode	record_impl (T *obj, const std::string &key, ::Bool_t isOwner, ::Bool_t isConst)
	Internal implementation of the templated record method. More...

Friends
class	TEvent
	Make TEvent a friend of this class. More...

Transient data accessor/modifier functions
template<typename T >
::Bool_t	contains (const std::string &key) const
	Function checking if an object is available from the store. More...
template<typename T >
::Bool_t	isConst (const std::string &key) const
	Function checking if an object with a given type is constant. More...
template<typename T >
StatusCode	retrieve (const T *&obj, const std::string &key) const
	Retrieve either a constant or non-constant object from the store. More...
template<typename T >
StatusCode	retrieve (T *&obj, const std::string &key) const
	Retrieve a non-constant object from the store. More...
template<typename T >
StatusCode	record (T *obj, const std::string &key)
	Add an object to the store. More...
template<typename T >
StatusCode	record (std::unique_ptr< T > obj, const std::string &key)
	Add an object to the store, explicitly taking ownership of it. More...
template<typename T >
StatusCode	record (const T *obj, const std::string &key)
	Add a const object to the store. More...
template<typename T >
StatusCode	record (std::unique_ptr< const T > obj, const std::string &key)
	Add a const object to the store, explicitly taking ownership of it. More...
template<typename T >
void	keys (std::vector< std::string > &vkeys) const
	provide a list of keys associated with a type More...
const THolder *	holder (const std::string &key) const
	return holder for key More...
StatusCode	remove (const std::string &key)
	Remove an object from the store by name. More...
StatusCode	remove (void *ptr)
	Remove an object from the store by pointer. More...
void	clear ()
	Clear the store of all of its contents. More...

Detailed Description

A relatively simple transient store for objects created in analysis.

This is a very simple transient store for objects that are created during analysis, but don't have to be written to the output file(s). To make it easier for the analysis tools to communicate with each other similar to how they would do it in Athena (with StoreGateSvc), they can use this class.

The usage of this class is highly optional in analysis, it should only be used if really necessary. (Passing around objects in analysis code directly is usually a better approach than using a store in my mind...)

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 44 of file TStore.h.

Member Typedef Documentation

HashedKeys_t

typedef SG::SGKeyMap< std::string > xAOD::TStore::HashedKeys_t

protected

Type of the internal storage for the hashed keys of the object names.

Definition at line 164 of file TStore.h.

Objects_t

typedef std::map< std::string, THolder* > xAOD::TStore::Objects_t

protected

Type of the internal container storing all the objects.

Definition at line 162 of file TStore.h.

Constructor & Destructor Documentation

TStore() [1/2]

xAOD::TStore::TStore

(

)

Default constructor.

Definition at line 24 of file TStore.cxx.

      : m_objects(), m_keys() {
 
      setActive();
   }

TStore() [2/2]

xAOD::TStore::TStore ( const TStore &  )

delete

Disallow copying the object.

~TStore()

xAOD::TStore::~TStore ( )

virtual

Destructor.

Definition at line 30 of file TStore.cxx.

                   {
 
      // Clear the store before being deleted:
      clear();
 
      // If this object is set up as the active store at the moment,
      // notify the active store object that this object will no longer
      // be available.
      if( TActiveStore::store() == this ) {
         TActiveStore::setStore( nullptr );
      }
   }

Member Function Documentation

clear()

void xAOD::TStore::clear

(

)

Clear the store of all of its contents.

Definition at line 105 of file TStore.cxx.

                      {
 
      // Delete all the managed objects:
      Objects_t::iterator itr = m_objects.begin();
      Objects_t::iterator end = m_objects.end();
      for( ; itr != end; ++itr ) {
         delete itr->second;
      }
 
      // And clear the maps:
      m_objects.clear();
      m_keys.clear();
 
      return;
   }

contains() [1/4]

template<typename T >

::Bool_t xAOD::TStore::contains

(

const std::string &

key

)

const

Function checking if an object is available from the store.

contains() [2/4]

Bool_t xAOD::TStore::contains ( const std::string &  key, const std::type_info &  ti  ) const

protected

Non-templated function implementing the containment check.

Definition at line 152 of file TStore.cxx.

                                                             {
 
      // Look up this object:
      Objects_t::const_iterator itr = m_objects.find( key );
      if( itr == m_objects.end() ) {
         return kFALSE;
      }
 
      // Check if the object is of the right type:
      return itr->second->getAsConst( ti, kTRUE );
   }

contains() [3/4]

Bool_t xAOD::TStore::contains ( const void *  ptr ) const

protected

Check if an object with a given pointer is managed by the store.

This is a quite slow function.

It needs to check each managed object to possibly find which one of them has this pointer.

Parameters

ptr	Pointer to the object that may or may not be in the store

Returns

kTRUE if the object is managed by the store, or kFALSE if it isn't

Definition at line 343 of file TStore.cxx.

                                                  {
 
      // Loop over all the managed objects:
      Objects_t::const_iterator itr = m_objects.begin();
      Objects_t::const_iterator end = m_objects.end();
      for( ; itr != end; ++itr ) {
         // Check if this is the right object:
         if( itr->second->get() == ptr ) {
            return kTRUE;
         }
      }
 
      // We didn't find it:
      return kFALSE;
   }

contains() [4/4]

Bool_t xAOD::TStore::contains ( SG::sgkey_t  hash ) const

protected

Check if an object with a given hash is managed by the store.

This is a reasonably fast function.

It checks whether an object with the specified hashed key is managed by the store.

Parameters

hash	The hashed key of the object that we are looking for

Returns

kTRUE if the object is managed by the store, or kFALSE if it is not

Definition at line 330 of file TStore.cxx.

                                                 {
 
      // Do the check quickly:
      return ( m_keys.find( hash ) != m_keys.end() );
   }

getConstObject()

const void * xAOD::TStore::getConstObject ( const std::string &  key, const std::type_info &  ti  ) const

protected

Function retrieving a const object in a non-template way.

Definition at line 211 of file TStore.cxx.

                                                                      {
 
      // Look up this object:
      Objects_t::const_iterator itr = m_objects.find( key );
      if( itr == m_objects.end() ) {
         return 0;
      }
 
      // Try to retrieve it as the requested type:
      return itr->second->getAsConst( ti );
   }

getName() [1/2]

const std::string & xAOD::TStore::getName ( const void *  ptr ) const

protected

Get the name of a managed object.

This is just as slow as the previous contains function.

It needs to look at all the managed objects one by one to find under what name it is managed.

Parameters

ptr	Pointer to the object that we want to know the name of

Returns

The name with which this object was recorded into the store. Or an empty string of the object is not known to the store.

Definition at line 390 of file TStore.cxx.

                                                           {
 
      // Loop over all the managed objects:
      Objects_t::const_iterator itr = m_objects.begin();
      Objects_t::const_iterator end = m_objects.end();
      for( ; itr != end; ++itr ) {
         // Check if this is the right object:
         if( itr->second->get() == ptr ) {
            return itr->first;
         }
      }
      
      // We didn't find the object:
      ::Warning( "xAOD::TStore::getName", "Object %p is not held by the store",
                 ptr );
      static const std::string dummy( "" );
      return dummy;
   }

getName() [2/2]

const std::string & xAOD::TStore::getName ( SG::sgkey_t  hash ) const

protected

Get the name corresponding to a hashed key.

This is a fairly fast function.

Used by ElementLinks that point to objects in this store.

Parameters

hash	The hashed key for which we want to find the string key

Returns

The name corresponding to this hashed key if the hashed key is known, or an empty string if it isn't.

Definition at line 366 of file TStore.cxx.

                                                          {
 
      // Try to find the name associated with this key:
      HashedKeys_t::const_iterator itr = m_keys.find( hash );
      if( itr != m_keys.end() ) {
         // We found it:
         return itr->second;
      }
 
      // We didn't find it:
      ::Warning( "xAOD::TStore::getName", "Key 0x%08x not known by the store",
                 hash );
      static const std::string dummy( "" );
      return dummy;
   }

getNames()

void xAOD::TStore::getNames ( const std::string &  targetClassName, std::vector< std::string > &  vkeys  ) const

protected

Function determining the list keys associated with a type name.

Definition at line 409 of file TStore.cxx.

                                                                {
      std::set< std::string > keys;
 
      for ( const auto& pair : m_objects ) {
         const std::string& key = pair.first;
         const ::TClass* cl = pair.second->getClass();
         const std::type_info* ti = pair.second->getTypeInfo();
         std::string typeName;
         if (cl)
            typeName = cl->GetName();
         else if (ti)
            typeName = SG::normalizedTypeinfoName( *ti );
 
         if (!typeName.empty() && typeName == targetTypeName)
            keys.insert( key );
      }
 
      vkeys.insert( vkeys.end(), keys.begin(), keys.end() );
   }

getObject()

void * xAOD::TStore::getObject ( const std::string &  key, const std::type_info &  ti  ) const

protected

Function retrieving a non-const object in a non-template way.

Definition at line 191 of file TStore.cxx.

                                                           {
 
      // Look up this object:
      Objects_t::const_iterator itr = m_objects.find( key );
      if( itr == m_objects.end() ) {
         return 0;
      }
 
      if( itr->second->isConst() ) {
         ::Error( "xAOD::TStore::getObject",
                  XAOD_MESSAGE( "Cannot retrieve object with key \"%s\" of type %s as non-const" ),
                  key.c_str(), SG::normalizedTypeinfoName( ti ).c_str() );
         return nullptr;
      }
 
      // Try to retrieve it as the requested type:
      return itr->second->getAs( ti );
   }

holder()

const THolder * xAOD::TStore::holder

(

const std::string &

key

)

const

return holder for key

Definition at line 50 of file TStore.cxx.

                                                             {
      // Look up this object:
      Objects_t::const_iterator itr = m_objects.find( key );
      return (itr != m_objects.end() ? itr->second : nullptr);
   }

isConst() [1/2]

template<typename T >

::Bool_t xAOD::TStore::isConst

(

const std::string &

key

)

const

Function checking if an object with a given type is constant.

isConst() [2/2]

Bool_t xAOD::TStore::isConst ( const std::string &  key, const std::type_info &  ti  ) const

protected

Non-templated function implementing the const-ness check.

Definition at line 165 of file TStore.cxx.

                                                            {
 
      // Look up this object:
      Objects_t::const_iterator itr = m_objects.find( key );
      if( itr == m_objects.end() ) {
         ::Warning( "xAOD::TStore::isConst",
                    "Object with key \"%s\" not available in store",
                    key.c_str() );
         return kFALSE;
      }
 
      // Check if it can even be retrieved as a constant object of this type:
      if( ! itr->second->getAsConst( ti, kTRUE ) ) {
         const std::string typeName = SG::normalizedTypeinfoName( ti );
         ::Warning( "xAOD::TStore::isConst",
                    "Object with key \"%s\" can't be retrieved as type: %s",
                    key.c_str(), typeName.c_str() );
         return kFALSE;
      }
 
      // Now the question is just whether it can be retrieved as a non-const
      // object as well:
      return ( ! itr->second->getAs( ti, kTRUE ) );
   }

keys()

template<typename T >

void xAOD::TStore::keys

(

std::vector< std::string > &

vkeys

)

const

provide a list of keys associated with a type

operator=()

TStore& xAOD::TStore::operator= ( const TStore &  )

delete

Disallow copying the object.

print()

void xAOD::TStore::print

(

)

const

Print the current contents of the transient store.

This is really just meant for debugging an analysis code, to see what's going on in it.

Behaves a bit similar to StoreGateSvc::dump().

Definition at line 124 of file TStore.cxx.

                            {
 
      ::Info( "xAOD::TStore::print", "Contents of transient store:" );
      Objects_t::const_iterator itr = m_objects.begin();
      Objects_t::const_iterator end = m_objects.end();
      for( ; itr != end; ++itr ) {
         ::Info( "xAOD::TStore::print", "-----------------------------------" );
         ::Info( "xAOD::TStore::print", "  Name: %s", itr->first.c_str() );
         const ::TClass* cl = itr->second->getClass();
         const std::type_info* ti = itr->second->getTypeInfo();
         ::Info( "xAOD::TStore::print", "    Type: %s",
                 ( cl ? cl->GetName() :
                   ( ti ? SG::normalizedTypeinfoName( *ti ).c_str() :
                     "Unknown" ) ) );
         ::Info( "xAOD::TStore::print", "    Pointer: %p",
                 itr->second->get() );
         ::Info( "xAOD::TStore::print", "    IsOwner: %s",
                 ( itr->second->isOwner() ? "Yes" : "No" ) );
         ::Info( "xAOD::TStore::print", "    IsConst: %s",
                 ( itr->second->isConst() ? "Yes" : "No" ) );
         ::Info( "xAOD::TStore::print", "    HasDictionary: %s",
                 ( cl ? "Yes" : "No" ) );
      }
      ::Info( "xAOD::TStore::print", "-----------------------------------" );
 
      return;
   }

record() [1/8]

template<typename T >

StatusCode xAOD::TStore::record	(	const T *	obj,
		const std::string &	key
	)

Add a const object to the store.

record() [2/8]

template<class T >

StatusCode xAOD::TStore::record ( ConstDataVector< T > *  obj, const std::string &  key, const std::type_info &  ti, ::Bool_t  isOwner, ::Bool_t  isConst  )

protected

Function doing the first step of recording a ConstDataVector object.

record() [3/8]

template<typename T >

StatusCode xAOD::TStore::record	(	std::unique_ptr< const T >	obj,
		const std::string &	key
	)

Add a const object to the store, explicitly taking ownership of it.

record() [4/8]

template<typename T >

StatusCode xAOD::TStore::record	(	std::unique_ptr< T >	obj,
		const std::string &	key
	)

Add an object to the store, explicitly taking ownership of it.

record() [5/8]

template<typename T >

StatusCode xAOD::TStore::record	(	T *	obj,
		const std::string &	key
	)

Add an object to the store.

record() [6/8]

StatusCode xAOD::TStore::record ( THolder *  hldr, const std::string &  key  )

protected

Function doing the second step of recording a ConstDataVector object.

Definition at line 303 of file TStore.cxx.

                                                                  {
 
      // Make sure that the key is not yet taken:
      if( m_objects.find( key ) != m_objects.end() ) {
         ::Error( "xAOD::TStore::record",
                  XAOD_MESSAGE( "Trying to overwrite object with key \"%s\"" ),
                  key.c_str() );
         // We delete the holder object at this point. It's quite ugly in terms
         // of code readibility, but it results in fewer characters in the
         // template code...
         delete hldr;
         return StatusCode::FAILURE;
      }
 
      // Register the new object:
      m_objects[ key ] = hldr;
      m_keys[ Utils::hash( key ) ] = key;
      return StatusCode::SUCCESS;
   }

record() [7/8]

StatusCode xAOD::TStore::record ( void *  obj, const std::string &  key, const std::string &  classname, ::Bool_t  isOwner, ::Bool_t  isConst  )

protected

Function recording an object that has a dictionary available.

This internal function does the heavy lifting of recording objects into the store that have a proper ROOT dictionary.

Parameters

obj	Typeless pointer to the object being recorded
key	Key to record the object with
classname	The type name of the object being recorded
isOwner	If kTRUE, the store takes ownership of the object, otherwise it doesn't

Returns

The usual StatusCode types

Definition at line 234 of file TStore.cxx.

                                                               {
 
      // Cache
      using clCache_t = CxxUtils::ConcurrentStrMap<::TClass*, CxxUtils::SimpleUpdater>;
      static clCache_t clMap ATLAS_THREAD_SAFE {clCache_t::Updater_t()};
 
      // First check if we have this dictionary cached already:
      ::TClass* cl = 0;
      auto clItr = clMap.find( classname );
      if( clItr != clMap.end() ) {
         // If the cached value doesn't work, then bail now:
         if( ( ! clItr->second ) || ( ! clItr->second->IsLoaded() ) ) {
            return StatusCode::RECOVERABLE;
         }
         // Otherwise we're done:
         cl = clItr->second;
      }
 
      // If it's not cached, ask ROOT for it:
      if( ! cl ) {
         cl = ::TClass::GetClass( classname.c_str(), kTRUE, kTRUE );
         clMap.emplace( classname, cl );
      }
      if( ( ! cl ) || ( ! cl->IsLoaded() ) ) {
         return StatusCode::RECOVERABLE;
      }
 
      // Make sure that the key is not yet taken:
      if( m_objects.find( key ) != m_objects.end() ) {
         ::Error( "xAOD::TStore::record",
                  XAOD_MESSAGE( "Trying to overwrite object with key \"%s\"" ),
                  key.c_str() );
         return StatusCode::FAILURE;
      }
 
      // Register the new object:
      if( isConst )
         m_objects[ key ] = new THolder( const_cast<const void*>(obj), cl, isOwner );
      else
         m_objects[ key ] = new THolder( obj, cl, isOwner);
 
      m_keys[ Utils::hash( key ) ] = key;
      return StatusCode::SUCCESS;
   }

record() [8/8]

StatusCode xAOD::TStore::record ( void *  obj, const std::string &  key, const std::type_info &  ti, ::Bool_t  isOwner, ::Bool_t  isConst  )

protected

Function recording an object that has no dictionary.

Definition at line 281 of file TStore.cxx.

                                                               {
 
      // Make sure that the key is not yet taken:
      if( m_objects.find( key ) != m_objects.end() ) {
         ::Error( "xAOD::TStore::record",
                  XAOD_MESSAGE( "Trying to overwrite object with key \"%s\"" ),
                  key.c_str() );
         return StatusCode::FAILURE;
      }
 
      // Register the new object:
      if( isConst )
         m_objects[ key ] = new THolder( const_cast<const void*>(obj), ti, isOwner );
      else
         m_objects[ key ] = new THolder( obj, ti, isOwner );
 
      m_keys[ Utils::hash( key ) ] = key;
      return StatusCode::SUCCESS;
   }

record_impl()

template<typename T >

StatusCode xAOD::TStore::record_impl ( T *  obj, const std::string &  key, ::Bool_t  isOwner, ::Bool_t  isConst  )

private

Internal implementation of the templated record method.

remove() [1/2]

StatusCode xAOD::TStore::remove

(

const std::string &

key

)

Remove an object from the store by name.

Definition at line 57 of file TStore.cxx.

                                                   {
 
      // Look up this object:
      Objects_t::iterator itr = m_objects.find( key );
      if( itr == m_objects.end() ) {
         ::Warning( "xAOD::TStore::remove",
                    "Couldn't find object with key \"%s\"",
                    key.c_str() );
         return StatusCode::RECOVERABLE;
      }
 
      // Delete the hoder object:
      delete itr->second;
 
      // Now remove this element from the maps:
      m_objects.erase( itr );
      m_keys.erase( Utils::hash( key ) );
 
      // We were successful:
      return StatusCode::SUCCESS;
   }

remove() [2/2]

StatusCode xAOD::TStore::remove

(

void *

ptr

)

Remove an object from the store by pointer.

Definition at line 79 of file TStore.cxx.

                                        {
 
      // Look for this object:
      Objects_t::iterator itr = m_objects.begin();
      Objects_t::iterator end = m_objects.end();
      for( ; itr != end; ++itr ) {
 
         // Check if this is the object in question:
         if( itr->second->get() != ptr ) {
            continue;
         }
 
         // Yes, it is...
         delete itr->second;
         m_keys.erase( Utils::hash( itr->first ) );
         m_objects.erase( itr );
         return StatusCode::SUCCESS;
      }
 
      // We didn't find the object in the store:
      ::Warning( "xAOD::TStore::remove",
                 "Couldn't find object with pointer %p",
                 ptr );
      return StatusCode::RECOVERABLE;
   }

retrieve() [1/2]

template<typename T >

StatusCode xAOD::TStore::retrieve	(	const T *&	obj,
		const std::string &	key
	)		const

Retrieve either a constant or non-constant object from the store.

retrieve() [2/2]

template<typename T >

StatusCode xAOD::TStore::retrieve	(	T *&	obj,
		const std::string &	key
	)		const

Retrieve a non-constant object from the store.

setActive()

void xAOD::TStore::setActive

(

)

Set this as the active transient store in the application.

Definition at line 43 of file TStore.cxx.

                          {
 
      TActiveStore::setStore( this );
      return;
   }

Friends And Related Function Documentation

TEvent

friend class TEvent

friend

Make TEvent a friend of this class.

Definition at line 47 of file TStore.h.

Member Data Documentation

m_keys

HashedKeys_t xAOD::TStore::m_keys

protected

The key map.

Definition at line 169 of file TStore.h.

m_objects

Objects_t xAOD::TStore::m_objects

protected

The object storage.

Definition at line 167 of file TStore.h.

---

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

• TStore.h
• TStore.cxx