xAOD::AuxInfoBase Class Reference

Common base class for auxiliary info objects. More...

#include <AuxInfoBase.h>

Inherits SG::IAuxStore, SG::IAuxStoreIO, SG::IAuxStoreHolder, and ILockable.

Inherited by DMTest::CInfoAuxContainer_v1, DMTest::CLinksAuxInfo_v1, DMTest::JVecAuxInfo_v1, DMTest::PLinksAuxInfo_v1, xAOD::CMMRoIAuxInfo_v1, xAOD::CTPResultAuxInfo_v1, xAOD::EnergySumRoIAuxInfo_v1, xAOD::EnergySumRoIAuxInfo_v2, xAOD::EventAuxInfo_v1, xAOD::EventAuxInfo_v2, xAOD::EventAuxInfo_v3, xAOD::EventShapeAuxInfo_v1, xAOD::FileMetaDataAuxInfo_v1, xAOD::JetEtRoIAuxInfo_v1, xAOD::RoiDescriptorStoreAuxInfo_v1, xAOD::TrigDecisionAuxInfo_v1, and xAOD::TrigNavigationAuxInfo_v1.

Public Types
typedef SG::auxid_t	auxid_t
	The aux ID type definition.
typedef SG::auxid_set_t	auxid_set_t
	The aux ID set type definition.
template<class T, class ALLOC = std::allocator<T>>
using	AuxVariable_t = T
	Declare how to wrap variables for this sort of base.
template<class T, class ALLOC = std::allocator<T>>
using	LinkedVariable_t = std::vector<T, ALLOC>
enum	AuxStoreType { AST_ObjectStore = 0 , AST_ContainerStore = 1 }
	Type of the auxiliary store. More...

Public Member Functions
	AuxInfoBase (bool allowDynamicVars=true)
	Default constructor.
	AuxInfoBase (const AuxInfoBase &parent)
	Copy constructor.
	AuxInfoBase (SG::IAuxStore *store)
	Constructor receiving a "dynamic auxiliary store".
	~AuxInfoBase ()
	Destructor.
AuxInfoBase &	operator= (const AuxInfoBase &rhs)
	Assignment operator.
template<typename T>
auxid_t	getAuxID (const std::string &name, T &, SG::AuxVarFlags flags=SG::AuxVarFlags::None, const SG::auxid_t linkedVariable=SG::null_auxid)
	Get the auxiliary ID for one of the persistent variables.
template<typename T>
void	regAuxVar (auxid_t auxid, const std::string &name, T &info)
	Register one of the persistent variables internally.
virtual bool	insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore=SG::auxid_set_t())=0
	Move all elements from other to this store.
Functions implementing the SG::IAuxStoreHolder interface
virtual SG::IAuxStore *	getStore () override
	Get the currently used internal store object.
virtual const SG::IAuxStore *	getStore () const override
	Get the currently used internal store object.
virtual void	setStore (SG::IAuxStore *store) override
	Set a different internal store object.
virtual AuxStoreType	getStoreType () const override
	Return the type of the store object.
Functions implementing the SG::IConstAuxStore interface
virtual const void *	getData (auxid_t auxid) const override
	Get a pointer to a given array.
virtual const SG::IAuxTypeVector *	getVector (SG::auxid_t auxid) const override final
	Return vector interface for one aux data item.
virtual const auxid_set_t &	getAuxIDs () const override
	Get the types(names) of variables handled by this container.
virtual const auxid_set_t &	getDecorIDs () const override
	Get the types(names) of decorations handled by this container.
virtual SG::auxid_set_t	getCopyIDs (bool warnUnlocked=false) const override
	Get the set of variables that we should deep copy.
virtual bool	isDecoration (auxid_t auxid) const override
	Test if a variable is a decoration.
virtual void *	getDecoration (auxid_t auxid, size_t size, size_t capacity) override
	Get a pointer to a given array, as a decoration.
virtual void	lock () override
	Lock the container.
virtual bool	clearDecorations () override
	Clear all decorations.
virtual size_t	size () const override
	Get the size of the container.
virtual void	lockDecoration (SG::auxid_t auxid) override
	Lock a decoration.
virtual const SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) const override
	Return interface for a linked variable.
virtual void	toTransient (const EventContext &ctx) override
	Perform processing on aux variable objects just after reading to make them usable as transient objects.
Functions implementing the SG::IAuxStore interface
virtual void *	getData (auxid_t auxid, size_t size, size_t capacity) override
	Get a pointer to a given array, creating the array if necessary.
virtual const auxid_set_t &	getWritableAuxIDs () const override
	Return a set of writable data identifiers.
virtual bool	resize (size_t size) override
	Resize the arrays to a given size.
virtual void	reserve (size_t size) override
	Reserve a given size for the arrays.
virtual void	shift (size_t pos, ptrdiff_t offs) override
	Shift the contents of the stored arrays.
virtual bool	insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore) override
	Insert contents of another store via move.
virtual bool	setOption (auxid_t id, const SG::AuxDataOption &option) override
	Make an option setting on an aux variable.
virtual SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) override
	Return interface for a linked variable.
Functions implementing the SG::IAuxStoreIO interface
virtual const void *	getIOData (auxid_t auxid) const override
	Get a pointer to the data being stored for one aux data item.
virtual const std::type_info *	getIOType (auxid_t auxid) const override
	Return the type of the data to be stored for one aux data item.
virtual const auxid_set_t &	getDynamicAuxIDs () const override
	Get the types(names) of variables created dynamically.
virtual SG::auxid_set_t	getSelectedAuxIDs () const override
	Get the IDs of the selected dynamic Aux variables (for writing).
Functions managing the instance name of the container
const char *	name () const
	Get the name of the container instance.
void	setName (const char *name)
	Set the name of the container instance.

Static Public Attributes
static constexpr bool	supportsThinning = true
	Mark that this type supports thinning operations.

Private Types
typedef AthContainers_detail::mutex	mutex_t
	Mutex for multithread synchronization.
typedef AthContainers_detail::lock_guard< mutex_t >	guard_t

Private Attributes
auxid_set_t	m_auxids
	Internal list of all available variables.
std::vector< SG::IAuxTypeVector * >	m_vecs
	Internal list of all managed variables.
SG::IAuxStore *	m_store
	Internal dynamic auxiliary store object.
SG::IAuxStoreIO *	m_storeIO
	The IO interface to the internal auxiliary store.
bool	m_ownsStore
	Flag deciding if the object owns the dynamic store or not.
bool	m_locked
	Has the container been locked?
mutex_t	m_mutex
std::string	m_name
	Name of the container in memory. Set externally.

Detailed Description

Common base class for auxiliary info objects.

This class should be used as the base for classes describing auxiliary information about standalone objects. The most important example of this is the xAOD::EventInfo object...

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

Revision

793737

Date

2017-01-24 21:11:10 +0100 (Tue, 24 Jan 2017)

Definition at line 41 of file AuxInfoBase.h.

Member Typedef Documentation

auxid_set_t

typedef SG::auxid_set_t xAOD::AuxInfoBase::auxid_set_t

The aux ID set type definition.

Definition at line 51 of file AuxInfoBase.h.

auxid_t

typedef SG::auxid_t xAOD::AuxInfoBase::auxid_t

The aux ID type definition.

Definition at line 49 of file AuxInfoBase.h.

AuxVariable_t

template<class T, class ALLOC = std::allocator<T>>

using xAOD::AuxInfoBase::AuxVariable_t = T

Declare how to wrap variables for this sort of base.

Definition at line 183 of file AuxInfoBase.h.

guard_t

typedef AthContainers_detail::lock_guard< mutex_t > xAOD::AuxInfoBase::guard_t

private

Definition at line 216 of file AuxInfoBase.h.

LinkedVariable_t

template<class T, class ALLOC = std::allocator<T>>

using xAOD::AuxInfoBase::LinkedVariable_t = std::vector<T, ALLOC>

Definition at line 185 of file AuxInfoBase.h.

mutex_t

typedef AthContainers_detail::mutex xAOD::AuxInfoBase::mutex_t

private

Mutex for multithread synchronization.

Definition at line 215 of file AuxInfoBase.h.

Member Enumeration Documentation

AuxStoreType

enum SG::IAuxStoreHolder::AuxStoreType

inherited

Type of the auxiliary store.

In the xAOD EDM we use auxiliary store objects in some cases to describe a single object, and in most cases to describe a container of objects. This enumeration declares which type the object implementing this interface is.

Enumerator
AST_ObjectStore	The store describes a single object.
AST_ContainerStore	The store describes a container.

Definition at line 68 of file IAuxStoreHolder.h.

                        {
         AST_ObjectStore    = 0, 
         AST_ContainerStore = 1  
      };

Constructor & Destructor Documentation

AuxInfoBase() [1/3]

xAOD::AuxInfoBase::AuxInfoBase

(

bool

allowDynamicVars = true

)

Default constructor.

Definition at line 26 of file AuxInfoBase.cxx.

      : SG::IAuxStore(),
        m_auxids(), m_vecs(), m_store( nullptr ), m_storeIO( nullptr ),
        m_ownsStore( true ),
        m_locked( false ),
        m_name( "UNKNOWN" ) {
 
      if( allowDynamicVars ) {
         m_store = new SG::AuxStoreStandalone();
         m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
      }
   }

AuxInfoBase() [2/3]

xAOD::AuxInfoBase::AuxInfoBase

(

const AuxInfoBase &

parent

)

Copy constructor.

This is an interesting one.

The internal variables of AuxInfoBase are set up by the derived class(es) at construction. So, this internal state is not to be copied!

However, since the derived classes (the contents of their regular members) are allowed to be copied, let's not make this constructor private.

Definition at line 47 of file AuxInfoBase.cxx.

      : SG::IAuxStore(),
        m_auxids(), m_vecs(), m_store( nullptr ), m_storeIO( nullptr ),
        m_ownsStore( true ),
        m_locked( false )
   {
      // Keep the source unmutable during copy
      guard_t guard( parent.m_mutex );
      m_name = parent.m_name;
 
      // Unfortunately the dynamic variables can not be copied this easily...
      if( parent.m_store ) {
         m_ownsStore = false;
         // cppcheck-suppress copyCtorPointerCopying
         m_store = parent.m_store;
         m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
         m_auxids.insert( m_store->getAuxIDs().begin(),
                          m_store->getAuxIDs().end() );
      }
   }

AuxInfoBase() [3/3]

xAOD::AuxInfoBase::AuxInfoBase

(

SG::IAuxStore *

store

)

Constructor receiving a "dynamic auxiliary store".

This constructor is used to wrap another object that is stored in StoreGate, and hence we should not take ownership of.

Parameters

store

Another store that should be wrapped, but not owned

Definition at line 73 of file AuxInfoBase.cxx.

      : SG::IAuxStore(),
        m_auxids(), m_vecs(),
        m_store( store ),
        m_storeIO( nullptr ), m_ownsStore( false ),
        m_locked( false ),
        m_name( "UNKNOWN" ) {
 
      m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
      if( m_store ) {
         m_auxids.insert (m_store->getAuxIDs());
      }
   }

~AuxInfoBase()

xAOD::AuxInfoBase::~AuxInfoBase

(

)

Destructor.

Definition at line 87 of file AuxInfoBase.cxx.

                             {
 
      std::vector< SG::IAuxTypeVector* >::iterator itr = m_vecs.begin();
      std::vector< SG::IAuxTypeVector* >::iterator end = m_vecs.end();
      for( ; itr != end; ++itr ) {
         if( ! *itr ) continue;
         delete *itr;
      }
 
      if( m_store && m_ownsStore ) delete m_store;
   }

Member Function Documentation

clearDecorations()

bool xAOD::AuxInfoBase::clearDecorations ( )

overridevirtual

Clear all decorations.

Definition at line 326 of file AuxInfoBase.cxx.

                                      {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Clear the decorations that are in the dynamic store:
      bool anycleared = false;
      if( m_store ) {
         anycleared = m_store->clearDecorations();
      }
      // Early exit if there were no decorations.
      if (!anycleared) return false;
 
      // Reconstruct the list of managed auxiliary IDs from scratch:
      auxid_set_t ids;
      for( auxid_t auxid = 0; auxid < m_vecs.size(); ++auxid ) {
         if( m_vecs[ auxid ] ) {
            ids.insert( auxid );
         }
      }
      if( m_store ) {
        ids.insert (m_store->getAuxIDs());
      }
      m_auxids = std::move(ids);
      
      return true;
   }

getAuxID()

template<typename T>

auxid_t xAOD::AuxInfoBase::getAuxID	(	const std::string &	name,
		T &	,
		SG::AuxVarFlags	flags = SG::AuxVarFlags::None,
		const SG::auxid_t	linkedVariable = SG::null_auxid )

Get the auxiliary ID for one of the persistent variables.

getAuxIDs()

const AuxInfoBase::auxid_set_t & xAOD::AuxInfoBase::getAuxIDs ( ) const

overridevirtual

Get the types(names) of variables handled by this container.

Definition at line 254 of file AuxInfoBase.cxx.

                                {
 
      // Return the full list of IDs:
      return getWritableAuxIDs();
   }

getCopyIDs()

SG::auxid_set_t xAOD::AuxInfoBase::getCopyIDs ( bool warnUnlocked = false ) const

overridevirtual

Get the set of variables that we should deep copy.

Reimplemented in xAOD::EventAuxInfo_v3.

Definition at line 239 of file AuxInfoBase.cxx.

   {
     return SG::getCopyIDs (getAuxIDs(), getDecorIDs(), warnUnlocked, {});
   }

getData() [1/2]

const void * xAOD::AuxInfoBase::getData ( auxid_t auxid ) const

overridevirtual

Get a pointer to a given array.

Definition at line 196 of file AuxInfoBase.cxx.

                                                         {
 
      const SG::IAuxTypeVector* v = getVector( auxid );
      if( v ) {
         return v->toPtr();
      }
      return nullptr;
   }

getData() [2/2]

void * xAOD::AuxInfoBase::getData ( auxid_t auxid, size_t size, size_t capacity )

overridevirtual

Get a pointer to a given array, creating the array if necessary.

Implements SG::IAuxStore.

Definition at line 446 of file AuxInfoBase.cxx.

                                                 {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
 
         if( m_store ) {
            void* result = m_store->getData( auxid, size, capacity );
            if( result ) {
               m_auxids.insert( auxid );
               const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
               auxid_t linked_id = r.linkedVariable( auxid );
               if (linked_id != SG::null_auxid) {
                  m_auxids.insert( linked_id );
               }
            }
            return result;
         } else {
            std::println( "ERROR xAOD::AuxInfoBase::getData "
                          "Unknown variable ({}) requested",
                          SG::AuxTypeRegistry::instance().getName( auxid ) );
            return nullptr;
         }
      }
      m_vecs[ auxid ]->reserve( capacity );
      if (m_vecs[ auxid ]->size() < size) {
         m_vecs[ auxid ]->resize( size );
      }
 
      return m_vecs[ auxid ]->toPtr();
   }

getDecoration()

void * xAOD::AuxInfoBase::getDecoration ( auxid_t auxid, size_t size, size_t capacity )

overridevirtual

Get a pointer to a given array, as a decoration.

Reimplemented in xAOD::EventAuxInfo_v1, xAOD::EventAuxInfo_v2, and xAOD::EventAuxInfo_v3.

Definition at line 270 of file AuxInfoBase.cxx.

                                                       {
     {
       // Guard against multi-threaded execution:
       guard_t guard( m_mutex );
 
       // Check if we have it as a static variable:
       if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         // If not, but we have a dynamic store, push it in there:
         if( m_store ) {
           void* result = m_store->getDecoration( auxid, size, capacity );
           if( result ) {
              m_auxids.insert( auxid );
              const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
              auxid_t linked_id = r.linkedVariable( auxid );
              if (linked_id != SG::null_auxid) {
                 m_auxids.insert( linked_id );
              }
           }
           return result;
         }
         // If we don't have a dynamic store, complain:
         else {
           std::println( "ERROR xAOD::AuxInfoBase::getDecoration "
                         "Can't provide variable {}",
                         SG::AuxTypeRegistry::instance().getName( auxid ) );
           return nullptr;
         }
       }
 
       // If the container is locked, static variables can't be accessed this
       // way:
       if( m_locked ) {
         throw SG::ExcStoreLocked( auxid );
       }
     }
 
     // If the container is not locked, then fall back on the normal accessor
     // function:
     return getData( auxid, size, capacity );
   }

getDecorIDs()

const AuxInfoBase::auxid_set_t & xAOD::AuxInfoBase::getDecorIDs ( ) const

overridevirtual

Get the types(names) of decorations handled by this container.

Definition at line 261 of file AuxInfoBase.cxx.

                                  {
 
      if( m_store ) {
         return m_store->getDecorIDs();
      }
      static const auxid_set_t empty;
      return empty;
   }

getDynamicAuxIDs()

const AuxInfoBase::auxid_set_t & xAOD::AuxInfoBase::getDynamicAuxIDs ( ) const

overridevirtual

Get the types(names) of variables created dynamically.

Implements SG::IAuxStoreIO.

Definition at line 655 of file AuxInfoBase.cxx.

                                       {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // All the variables handled by the internal store are dynamic
      // if such a store exists:
      if( m_storeIO ) {
         // I mean, all the variables. Not just the ones reported as dynamic
         // by the internal object. Because the internal object may be something
         // that was put into this one in order to achieve data slimming.
         return m_store->getAuxIDs();
      }
 
      // In case we don't use an internal store, there are no dynamic
      // variables:
      static const auxid_set_t dummy (0);
      return dummy;
   }

getIOData()

const void * xAOD::AuxInfoBase::getIOData ( auxid_t auxid ) const

overridevirtual

Get a pointer to the data being stored for one aux data item.

Implements SG::IAuxStoreIO.

Definition at line 606 of file AuxInfoBase.cxx.

                                                           {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_storeIO ) {
            return m_storeIO->getIOData( auxid );
         } else {
            std::println( "ERROR xAOD::AuxInfoBase::getIOData "
                          "Unknown variable ({}) requested",
                          SG::AuxTypeRegistry::instance().getName( auxid ) );
            return nullptr;
         }
      }
 
      // Update the statistics for this variable. The dynamic store registers
      // its own variable accesses.
      IOStats::instance().stats().readBranch( m_name, auxid );
 
      if( m_vecs[ auxid ]->isLinked() )
         return m_vecs[ auxid ]->toVector();
      else
         return m_vecs[ auxid ]->toPtr();
   }

getIOType()

const std::type_info * xAOD::AuxInfoBase::getIOType ( auxid_t auxid ) const

overridevirtual

Return the type of the data to be stored for one aux data item.

Implements SG::IAuxStoreIO.

Definition at line 632 of file AuxInfoBase.cxx.

                                                                   {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_storeIO ) {
            return m_storeIO->getIOType( auxid );
         } else {
            std::println ("ERROR xAOD::AuxInfoBase::getIOType "
                          "Unknown variable ({}) requested",
                          SG::AuxTypeRegistry::instance().getName( auxid ) );
            return nullptr;
         }
      }
 
      if( m_vecs[ auxid ]->isLinked() )
         return SG::AuxTypeRegistry::instance().getType( auxid );
      else
         return SG::AuxTypeRegistry::instance().getVecType( auxid );
   }

getSelectedAuxIDs()

AuxInfoBase::auxid_set_t xAOD::AuxInfoBase::getSelectedAuxIDs ( ) const

overridevirtual

Get the IDs of the selected dynamic Aux variables (for writing).

Reimplemented from SG::IAuxStoreIO.

Definition at line 676 of file AuxInfoBase.cxx.

                                        {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // All the variables handled by the internal store are dynamic
      // if such a store exists:
      if( m_storeIO && m_store) {
         // I mean, all the variables. Not just the ones reported as dynamic
         // by the internal object. Because the internal object may be something
         // that was put into this one in order to achieve data slimming.
         return m_store->getAuxIDs();
      }
 
      // In case we don't use an internal store, there are no dynamic
      // variables:
      return auxid_set_t();
   }

getStore() [1/2]

const SG::IAuxStore * xAOD::AuxInfoBase::getStore ( ) const

overridevirtual

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 147 of file AuxInfoBase.cxx.

   {
      return m_store;
   }

getStore() [2/2]

SG::IAuxStore * xAOD::AuxInfoBase::getStore ( )

overridevirtual

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 141 of file AuxInfoBase.cxx.

   {
      return m_store;
   }

getStoreType()

virtual AuxStoreType xAOD::AuxInfoBase::getStoreType ( ) const

inlineoverridevirtual

Return the type of the store object.

Implements SG::IAuxStoreHolder.

Definition at line 75 of file AuxInfoBase.h.

{ return AST_ObjectStore; }

getVector()

const SG::IAuxTypeVector * xAOD::AuxInfoBase::getVector ( SG::auxid_t auxid ) const

finaloverridevirtual

Return vector interface for one aux data item.

Definition at line 205 of file AuxInfoBase.cxx.

                                                                       {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_store ) {
            const SG::IAuxTypeVector* result = m_store->getVector( auxid );
            if( result ) {
               auxid_set_t& auxids_nc ATLAS_THREAD_SAFE =
                 const_cast<auxid_set_t&> (m_auxids);
               auxids_nc.insert( auxid );
               const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
               auxid_t linked_id = r.linkedVariable( auxid );
               if (linked_id != SG::null_auxid) {
                  auxids_nc.insert( linked_id );
               }
            }
            return result;
         } else {
            std::println( "ERROR xAOD::AuxInfoBase::getData "
                          "Unknown variable ({}) requested",
                          SG::AuxTypeRegistry::instance().getName( auxid ) );
            return nullptr;
         }
      }
 
      // Update the statistics for this variable. The dynamic store registers
      // its own variable accesses.
      IOStats::instance().stats().readBranch( m_name, auxid );
 
      return m_vecs[ auxid ];
   }

getWritableAuxIDs()

const AuxInfoBase::auxid_set_t & xAOD::AuxInfoBase::getWritableAuxIDs ( ) const

overridevirtual

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 481 of file AuxInfoBase.cxx.

                                        {
 
      // Return the full list of known IDs. The constness of this object's
      // members comes from the object being const or not.
      return m_auxids;
   }

insertMove() [1/2]

virtual bool SG::IAuxStore::insertMove ( size_t pos, IAuxStore & other, const SG::auxid_set_t & ignore = SG::auxid_set_t() )

pure virtualinherited

Move all elements from other to this store.

Parameters

pos	The starting index of the insertion.
other	Store from which to do the move.
ignore	Set of variables that should not be added to the store.

Let len be the size of other. The store will be increased in size by len elements, with the elements at pos being copied to pos+len. Then, for each auxiliary variable, the entire contents of that variable for other will be moved to this store at index pos. This will be done via move semantics if possible; otherwise, it will be done with a copy. Variables present in this store but not in other will have the corresponding elements default-initialized. Variables in other but not in this store will be added unless they are in ignore.

Returns true if it is known that none of the vectors' memory moved, false otherwise.

insertMove() [2/2]

bool xAOD::AuxInfoBase::insertMove ( size_t pos, IAuxStore & other, const SG::auxid_set_t & ignore )

overridevirtual

Insert contents of another store via move.

Definition at line 570 of file AuxInfoBase.cxx.

                                                          {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check if the container is locked:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "insertMove" );
      }
 
      // We are just not allowed to do this...
      throw std::runtime_error( "Calling insertMove on a non-vector" );
 
      return false;
   }

isDecoration()

bool xAOD::AuxInfoBase::isDecoration ( auxid_t auxid ) const

overridevirtual

Test if a variable is a decoration.

Reimplemented in xAOD::EventAuxInfo_v1, xAOD::EventAuxInfo_v2, and xAOD::EventAuxInfo_v3.

Definition at line 244 of file AuxInfoBase.cxx.

   {
     guard_t guard( m_mutex );
     if (m_store) {
       return m_store->isDecoration (auxid);
     }
     return false;
   }

linkedVector() [1/2]

const SG::IAuxTypeVector * xAOD::AuxInfoBase::linkedVector ( SG::auxid_t auxid ) const

overridevirtual

Return interface for a linked variable.

Definition at line 363 of file AuxInfoBase.cxx.

   {
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      auxid_t linked_id = r.linkedVariable( auxid );
      if (linked_id != SG::null_auxid) {
         guard_t guard( m_mutex );
         if (linked_id < m_vecs.size() && m_vecs[ linked_id ]) {
            return m_vecs[ linked_id ];
         }
         if (m_store) {
            return CxxUtils::as_const_ptr(m_store)->linkedVector( auxid );
         }
      }
      return nullptr;
   }

linkedVector() [2/2]

SG::IAuxTypeVector * xAOD::AuxInfoBase::linkedVector ( SG::auxid_t auxid )

overridevirtual

Return interface for a linked variable.

Reimplemented from SG::IAuxStore.

Definition at line 380 of file AuxInfoBase.cxx.

   {
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      auxid_t linked_id = r.linkedVariable( auxid );
      if (linked_id != SG::null_auxid) {
         guard_t guard( m_mutex );
         if (linked_id < m_vecs.size() && m_vecs[ linked_id ]) {
            return m_vecs[ linked_id ];
         }
         if (m_store) {
            return m_store->linkedVector( auxid );
         }
      }
      return nullptr;
   }

lock()

void xAOD::AuxInfoBase::lock ( )

overridevirtual

Lock the container.

Definition at line 312 of file AuxInfoBase.cxx.

                          {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Lock the container and the dynamic store:
      m_locked = true;
      if( m_store ) {
         m_store->lock();
      }
 
      return;
   }

lockDecoration()

void xAOD::AuxInfoBase::lockDecoration ( SG::auxid_t auxid )

overridevirtual

Lock a decoration.

Reimplemented in xAOD::EventAuxInfo_v1, xAOD::EventAuxInfo_v2, and xAOD::EventAuxInfo_v3.

Definition at line 355 of file AuxInfoBase.cxx.

   { 
     guard_t guard (m_mutex);
     if (m_store) {
       m_store->lockDecoration (auxid);
     }
   }

name()

const char * xAOD::AuxInfoBase::name

(

)

const

Get the name of the container instance.

Definition at line 698 of file AuxInfoBase.cxx.

                                       {
 
      return m_name.c_str();
   }

operator=()

AuxInfoBase & xAOD::AuxInfoBase::operator=

(

const AuxInfoBase &

rhs

)

Assignment operator.

Just like the copy constructor, this operator doesn't actually copy anything either.

It's just here to make it clear to C++ that the internal state of these objects is not to be messed with.

Returns

A reference to this same object

Definition at line 106 of file AuxInfoBase.cxx.

                                                {
 
      // Protect against self-assignment:
      if( this == &rhs ) return *this;
 
      // Keep the source unmutable during copy
      std::scoped_lock  lck{m_mutex, rhs.m_mutex};
 
      // Clean up after the old dynamic store:
      if( m_store && m_ownsStore ) {
         m_auxids -= m_store->getAuxIDs();
         delete m_store;
      }
      m_store = nullptr;
      m_storeIO = nullptr;
      m_ownsStore = true;
 
      // Take posession of the new dynamic store:
      if( rhs.m_store ) {
         m_ownsStore = false;
         m_store = rhs.m_store;
         m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
         m_auxids.insert (m_store->getAuxIDs());
      }
 
      m_name = rhs.m_name;
 
      return *this;
   }

regAuxVar()

template<typename T>

void xAOD::AuxInfoBase::regAuxVar	(	auxid_t	auxid,
		const std::string &	name,
		T &	info )

Register one of the persistent variables internally.

reserve()

void xAOD::AuxInfoBase::reserve ( size_t size )

overridevirtual

Reserve a given size for the arrays.

Implements SG::IAuxStore.

Definition at line 522 of file AuxInfoBase.cxx.

                                          {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check if the container is locked:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "reserve" );
      }
 
      // Do a test already here:
      if( size != 1 ) {
         throw std::runtime_error( "Calling reserve with != 1 on a "
                                   "non-vector" );
      }
 
      // Do the operation on the static variables:
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v && !v->isLinked()) {
            v->reserve( size );
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
         m_store->reserve( size );
      }
 
      return;
   }

resize()

bool xAOD::AuxInfoBase::resize ( size_t size )

overridevirtual

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 488 of file AuxInfoBase.cxx.

                                         {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check if the container is locked:
      if( m_locked ) {
        throw SG::ExcStoreLocked( "resize" );
      }
 
      // Do a test already here:
      if( size != 1 ) {
         throw std::runtime_error( "Calling resize with != 1 on a "
                                   "non-vector" );
      }
 
      // Do the operation on the static variables:
      bool nomoves = true;
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v && !v->isLinked()) {
           if (!v->resize( size ))
             nomoves = false;
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
        if (!m_store->resize( size ))
          nomoves = false;
      }
 
      return nomoves;
   }

setName()

void xAOD::AuxInfoBase::setName

(

const char *

name

)

Set the name of the container instance.

Definition at line 703 of file AuxInfoBase.cxx.

                                               {
 
      m_name = name;
      return;
   }

setOption()

bool xAOD::AuxInfoBase::setOption ( auxid_t id, const SG::AuxDataOption & option )

overridevirtual

Make an option setting on an aux variable.

Reimplemented from SG::IAuxStore.

Definition at line 588 of file AuxInfoBase.cxx.

                                                                          {
 
      if (id < m_vecs.size() && m_vecs[id] != nullptr)
         return m_vecs[id]->setOption( option );
      if (m_store)
         return m_store->setOption( id, option );
      return false;
   }

setStore()

void xAOD::AuxInfoBase::setStore ( SG::IAuxStore * store )

overridevirtual

Set a different internal store object.

This function is used by the I/O infrastructure to possibly put a store object into this one, which can interact with dynamic variables directly.

Note that the object takes ownership of the received store.

Parameters

store

The store that should be used for dynamic variable handling inside the object from now on

Implements SG::IAuxStoreHolder.

Definition at line 161 of file AuxInfoBase.cxx.

                                                  {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check that no funny business is going on:
      if( m_store == store ) return;
 
      // Clean up the current store object:
      if( m_store && m_ownsStore ) {
         m_auxids -= m_store->getAuxIDs();
         delete m_store;
      }
      m_store = nullptr;
      m_storeIO = nullptr;
 
      // Take posession of the new object:
      m_store = store;
      m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
      m_ownsStore = true;
      if( m_store ) {
        m_auxids.insert (m_store->getAuxIDs());
      }
 
      return;
   }

shift()

void xAOD::AuxInfoBase::shift ( size_t pos, ptrdiff_t offs )

overridevirtual

Shift the contents of the stored arrays.

Implements SG::IAuxStore.

Definition at line 553 of file AuxInfoBase.cxx.

                                                  {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check if the container is locked:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "shift" );
      }
 
      // We are just not allowed to do this...
      throw std::runtime_error( "Calling shift on a non-vector" );
 
      return;
   }

size()

size_t xAOD::AuxInfoBase::size ( ) const

overridevirtual

Get the size of the container.

Definition at line 415 of file AuxInfoBase.cxx.

                                  {
 
      // Should really always be 1, but do the general thing anyway...
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Try to find a variable:
      for (SG::auxid_t i : m_auxids) {
         if( ( i < m_vecs.size() ) && m_vecs[ i ] && !m_vecs[ i ]->isLinked()) {
            size_t sz = m_vecs[ i ]->size();
            if( sz > 0 ) {
               return sz;
            }
         }
      }
 
      // If we didn't find any statically defined variables, then we just
      // need to claim 1. Because pool::AuxStoreAPR at the moment always
      // returns 0 for the size.
      return 1;
   }

toTransient()

void xAOD::AuxInfoBase::toTransient ( const EventContext & ctx )

overridevirtual

Perform processing on aux variable objects just after reading to make them usable as transient objects.

Implements SG::IAuxStore.

Reimplemented in xAOD::EventAuxInfo_v1, xAOD::EventAuxInfo_v2, and xAOD::EventAuxInfo_v3.

Definition at line 397 of file AuxInfoBase.cxx.

   {
      // Guard against multi-threaded execution:
      guard_t guard (m_mutex);
 
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v) {
           v->toTransient( ctx );
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
        m_store->toTransient( ctx );
      }
   }

Member Data Documentation

m_auxids

auxid_set_t xAOD::AuxInfoBase::m_auxids

private

Internal list of all available variables.

Definition at line 201 of file AuxInfoBase.h.

m_locked

bool xAOD::AuxInfoBase::m_locked

private

Has the container been locked?

Definition at line 212 of file AuxInfoBase.h.

m_mutex

mutex_t xAOD::AuxInfoBase::m_mutex

mutableprivate

Definition at line 217 of file AuxInfoBase.h.

m_name

std::string xAOD::AuxInfoBase::m_name

private

Name of the container in memory. Set externally.

Definition at line 220 of file AuxInfoBase.h.

m_ownsStore

bool xAOD::AuxInfoBase::m_ownsStore

private

Flag deciding if the object owns the dynamic store or not.

Definition at line 210 of file AuxInfoBase.h.

m_store

SG::IAuxStore* xAOD::AuxInfoBase::m_store

private

Internal dynamic auxiliary store object.

Definition at line 206 of file AuxInfoBase.h.

m_storeIO

SG::IAuxStoreIO* xAOD::AuxInfoBase::m_storeIO

private

The IO interface to the internal auxiliary store.

Definition at line 208 of file AuxInfoBase.h.

m_vecs

std::vector< SG::IAuxTypeVector* > xAOD::AuxInfoBase::m_vecs

private

Internal list of all managed variables.

Definition at line 203 of file AuxInfoBase.h.

supportsThinning

bool SG::IAuxStore::supportsThinning = true

staticconstexprinherited

Mark that this type supports thinning operations.

See AthContainers/supportsThinning.h and AthenaPoolCnvSvc/T_AthenaPoolCnv.h. Helps guide which pool converter template will be used. If false, the default pool converter will be used rather than the aux store-specific one. Ordinary xAOD type should not touch this, but may be overridden in a derived class to handle certain special cases.

Definition at line 216 of file IAuxStore.h.

---

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

• AuxInfoBase.h
• AuxInfoBase.cxx