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.
	TStore (const TStore &)=delete
	Disallow copying the object.
virtual	~TStore ()
	Destructor.
TStore &	operator= (const TStore &)=delete
	Disallow copying the object.
void	setActive ()
	Set this as the active transient store in the application.
void	print () const
	Print the current contents of the transient store.
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.
template<typename T>
::Bool_t	isConst (const std::string &key) const
	Function checking if an object with a given type is constant.
template<typename T>
StatusCode	retrieve (const T *&obj, const std::string &key) const
	Retrieve either a constant or non-constant object from the store.
template<typename T>
StatusCode	retrieve (T *&obj, const std::string &key) const
	Retrieve a non-constant object from the store.
template<typename T>
StatusCode	record (T *obj, const std::string &key)
	Add an object to the store.
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.
template<typename T>
StatusCode	record (const T *obj, const std::string &key)
	Add a const object to the store.
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.
template<typename T>
void	keys (std::vector< std::string > &vkeys) const
	provide a list of keys associated with a type
const THolder *	holder (const std::string &key) const
	return holder for key
StatusCode	remove (const std::string &key)
	Remove an object from the store by name.
StatusCode	remove (void *ptr)
	Remove an object from the store by pointer.
void	clear ()
	Clear the store of all of its contents.

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

Protected Member Functions
::Bool_t	contains (const std::string &key, const std::type_info &ti) const
	Non-templated function implementing the containment check.
::Bool_t	isConst (const std::string &key, const std::type_info &ti) const
	Non-templated function implementing the const-ness check.
void *	getObject (const std::string &key, const std::type_info &ti) const
	Function retrieving a non-const object in a non-template way.
const void *	getConstObject (const std::string &key, const std::type_info &ti) const
	Function retrieving a const object in a non-template way.
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.
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.
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.
StatusCode	record (THolder *hldr, const std::string &key)
	Function doing the second step of recording a ConstDataVector object.
Functions mostly used by TEvent in the TVirtualEvent functions
::Bool_t	contains (SG::sgkey_t hash) const
	Check if an object with a given hash is managed by the store.
::Bool_t	contains (const void *ptr) const
	Check if an object with a given pointer is managed by the store.
const std::string &	getName (SG::sgkey_t hash) const
	Get the name corresponding to a hashed key.
const std::string &	getName (const void *ptr) const
	Get the name of a managed object.
void	getNames (const std::string &targetClassName, std::vector< std::string > &vkeys) const
	Function determining the list keys associated with a type name.

Protected Attributes
Objects_t	m_objects
	The object storage.
HashedKeys_t	m_keys
	The key map.
std::unordered_map< const void *, const std::string * >	m_names
	Key of each managed object, by object pointer (points into m_objects).

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.

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

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

Objects_t

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

protected

Type of the internal container storing all the objects.

Definition at line 165 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 95 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();
      m_names.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 143 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.

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 325 of file TStore.cxx.

                                                  {
 
      return m_names.contains( ptr );
   }

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 315 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 202 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.

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 357 of file TStore.cxx.

                                                           {
 
      auto itr = m_names.find( ptr );
      if( itr != m_names.end() ) {
         return *itr->second;
      }
 
      // 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 337 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 371 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 182 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 156 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 115 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 286 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:
      const auto itr = m_objects.emplace( key, hldr ).first;
      m_keys[ Utils::hash( key ) ] = key;
      // shortcut: one key per pointer, an object recorded twice (non-owning, from TPyStore) is lost by either remove; index all keys if that is ever used
      m_names.emplace( hldr->get(), &itr->first );
      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 225 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 )
         return record( new THolder( const_cast<const void*>(obj), cl, isOwner ), key );
      return record( new THolder( obj, cl, isOwner ), key );
   }

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 268 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 )
         return record( new THolder( const_cast<const void*>(obj), ti, isOwner ), key );
      return record( new THolder( obj, ti, isOwner ), key );
   }

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;
      }
 
      // Forget its pointer, and delete the holder object:
      m_names.erase( itr->second->get() );
      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 80 of file TStore.cxx.

                                        {
 
      // Look for this object:
      auto itr = m_names.find( ptr );
      if( itr == m_names.end() ) {
         ::Warning( "xAOD::TStore::remove",
                    "Couldn't find object with pointer %p",
                    ptr );
         return StatusCode::RECOVERABLE;
      }
 
      // Copy the key, removing the object destroys the string it points to:
      return remove( std::string( *itr->second ) );
   }

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 Symbol Documentation

Event

friend class Event

friend

Definition at line 50 of file TStore.h.

TEvent

friend class TEvent

friend

Make TEvent a friend of this class.

Definition at line 49 of file TStore.h.

Member Data Documentation

m_keys

HashedKeys_t xAOD::TStore::m_keys

protected

The key map.

Definition at line 172 of file TStore.h.

m_names

std::unordered_map< const void*, const std::string* > xAOD::TStore::m_names

protected

Key of each managed object, by object pointer (points into m_objects).

Definition at line 174 of file TStore.h.

m_objects

Objects_t xAOD::TStore::m_objects

protected

The object storage.

Definition at line 170 of file TStore.h.

---

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

• TStore.h
• TStore.cxx