Python interface to xAOD::TStore. More...

#include <TPyStore.h>

Inheritance diagram for xAOD::TPyStore:

Collaboration diagram for xAOD::TPyStore:

Public Member Functions
bool	pyContains (const std::string &key, const std::string &type) const
	Function checking if an object with a given key and type is available.
bool	pyIsConst (const std::string &key, const std::string &type) const
	Function checking if an object with a given key and type is constant.
StatusCode	pyRecord (void *obj, const std::string &key, const std::string &type)
	Record an object into the store in a typeless way.
void	dump () const
	Print the contents of the store using a Python friendly function.
	TStore ()
	Inherit the constructor(s) of `xAOD::TStore`.
	TStore (const TStore &)=delete
	Inherit the constructor(s) of `xAOD::TStore`.
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::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.
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.
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.
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.

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.

Detailed Description

Python interface to xAOD::TStore.

In order to make it possible to record objects that are created in Python, into an xAOD::TStore object (to be able to pass it to some tools that expect the object to be in the event for instance), this class extends the xAOD::TStore object with some non-template functions. Functions that are inconvenient to use from C++, but which allow for much more flexibility in PyROOT.

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 27 of file TPyStore.h.

Member Typedef Documentation

◆ HashedKeys_t

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

protectedinherited

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

Definition at line 166 of file TStore.h.

◆ Objects_t

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

protectedinherited

Type of the internal container storing all the objects.

Definition at line 164 of file TStore.h.

Member Function Documentation

◆ clear()

void xAOD::TStore::clear ( )

inherited

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

inherited

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

protectedinherited

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

protectedinherited

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

protectedinherited

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

◆ dump()

void xAOD::TPyStore::dump ( ) const

Print the contents of the store using a Python friendly function.

This is just a convenience function, to make it easier to print the contents of such objects in Python.

Since the base class's print() function has a special meaning in Python.

Definition at line 121 of file TPyStore.cxx.

                          {
 
  print();
  return;
}

◆ getConstObject()

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

protectedinherited

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

protectedinherited

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

protectedinherited

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

protectedinherited

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

protectedinherited

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

inherited

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

inherited

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

protectedinherited

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

inherited

provide a list of keys associated with a type

◆ print()

void xAOD::TStore::print ( ) const

inherited

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

◆ pyContains()

bool xAOD::TPyStore::pyContains	(	const std::string &	key,
		const std::string &	type ) const

Function checking if an object with a given key and type is available.

This function can be used in the same manner as TStore::contains<...>(...), but instead of providing a type, one gives it a type name.

Note that only types that have a proper ROOT dictionary can be used. Unlike C++, which allows one to insert any type of object into TStore.

Parameters

key	The key of the object that we're looking for
type	The type name of the object we're trying to access

Returns: true if the object is acessible, false otherwise

Definition at line 28 of file TPyStore.cxx.

                                                       {
 
  // Try to access the dictionary of this type.
  ::TClass* cl = ::TClass::GetClass(type.c_str());
  if (cl == nullptr) {
    ::Warning("xAOD::TPyStore::pyContains", "Type name \"%s\" not known",
              type.c_str());
    return false;
  }
 
  // Check if the dictionary can return a type_info.
  const std::type_info* ti = cl->GetTypeInfo();
  if (!ti) {
    ::Warning("xAOD::TPyStore::pyContains",
              "Type \"%s\" doesn't have a proper dictionary", type.c_str());
    return false;
  }
 
  // Use the base class to answer the question.
  return TStore::contains(key, *ti);
}

◆ pyIsConst()

bool xAOD::TPyStore::pyIsConst	(	const std::string &	key,
		const std::string &	type ) const

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

This function can be used in the same manner as TStore::isConst<...>(...), but instead of providing a type, one gives it a type name.

Note that only types that have a proper ROOT dictionary can be used. Unlike C++, which allows one to insert any type of object into TStore.

Parameters

key	The key of the object that we're looking for
type	The type name of the object we're trying to access

Returns: true if the object is acessible, false otherwise

Definition at line 63 of file TPyStore.cxx.

                                                      {
 
  // Try to access the dictionary of this type.
  ::TClass* cl = ::TClass::GetClass(type.c_str());
  if (cl == nullptr) {
    ::Warning("xAOD::TPyStore::pyIsConst", "Type name \"%s\" not known",
              type.c_str());
    return false;
  }
 
  // Check if the dictionary can return a type_info.
  const std::type_info* ti = cl->GetTypeInfo();
  if (ti == nullptr) {
    ::Warning("xAOD::TPyStore::pyIsConst",
              "Type \"%s\" doesn't have a proper dictionary", type.c_str());
    return false;
  }
 
  // Use the base class to answer the question.
  return TStore::isConst(key, *ti);
}

◆ pyRecord()

StatusCode xAOD::TPyStore::pyRecord	(	void *	obj,
		const std::string &	key,
		const std::string &	type )

Record an object into the store in a typeless way.

This function can be used in the same manner as TStore::record<...>(...), but instead of providing a type, one gives it a type name and a typeless pointer.

Note that only types that have a proper ROOT dictionary can be used. Unlike C++, which allows one to insert any type of object into TStore.

Also note that this function doesn't take ownership of the recorded object. In Python all the objects created by the interpreter are managed by the interpreter. So this code is not supposed to delete them, otherwise all hell breaks loose.

Parameters

obj	Pointer to the object to be put into the store
key	Key of the object in the store
type	The type name of the object we are inserting

Returns: The usual StatusCode types

Definition at line 103 of file TPyStore.cxx.

                                                     {
 
  // Simply forward the call to the appropriate function from the base
  // class.
  static constexpr bool IS_OWNER = true;
  static constexpr bool IS_CONST = false;
  RETURN_CHECK("xAOD::TPyStore::pyRecord",
               TStore::record(obj, key, type, IS_OWNER, IS_CONST));
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

◆ record() [1/8]

template<typename T>

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

inherited

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 )

protectedinherited

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 )

inherited

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 )

inherited

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 )

inherited

Add an object to the store.

◆ record() [6/8]

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

protectedinherited

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 )

protectedinherited

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 )

protectedinherited

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 )

privateinherited

Internal implementation of the templated record method.

◆ remove() [1/2]

StatusCode xAOD::TStore::remove ( const std::string & key )

inherited

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 )

inherited

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

inherited

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

inherited

Retrieve a non-constant object from the store.

◆ setActive()

void xAOD::TStore::setActive ( )

inherited

Set this as the active transient store in the application.

Definition at line 43 of file TStore.cxx.

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

◆ TStore() [1/2]

xAOD::TStore::TStore ( )

Inherit the constructor(s) of xAOD::TStore.

Definition at line 53 of file TStore.cxx.

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

◆ TStore() [2/2]

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

delete

Inherit the constructor(s) of xAOD::TStore.

Member Data Documentation

◆ m_keys

HashedKeys_t xAOD::TStore::m_keys

protectedinherited

The key map.

Definition at line 171 of file TStore.h.

◆ m_objects

Objects_t xAOD::TStore::m_objects

protectedinherited

The object storage.

Definition at line 169 of file TStore.h.

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

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Member Typedef Documentation

◆ HashedKeys_t

◆ Objects_t

Member Function Documentation

◆ clear()

◆ contains() [1/4]

◆ contains() [2/4]

◆ contains() [3/4]

◆ contains() [4/4]

◆ dump()

◆ getConstObject()

◆ getName() [1/2]

◆ getName() [2/2]

◆ getNames()

◆ getObject()

◆ holder()

◆ isConst() [1/2]

◆ isConst() [2/2]

◆ keys()

◆ print()

◆ pyContains()

◆ pyIsConst()

◆ pyRecord()

◆ record() [1/8]

◆ record() [2/8]

◆ record() [3/8]

◆ record() [4/8]

◆ record() [5/8]

◆ record() [6/8]

◆ record() [7/8]

◆ record() [8/8]

◆ record_impl()

◆ remove() [1/2]

◆ remove() [2/2]

◆ retrieve() [1/2]

◆ retrieve() [2/2]

◆ setActive()

◆ TStore() [1/2]

◆ TStore() [2/2]

Member Data Documentation

◆ m_keys

◆ m_objects