Base class for dynamic auxiliary stores saved into ByteStream. More...

#include <ByteStreamAuxContainer_v1.h>

Inheritance diagram for xAOD::ByteStreamAuxContainer_v1:

Public Types
typedef SG::auxid_t	auxid_t
	The aux ID type definition from IConstAuxStore.
typedef SG::auxid_set_t	auxid_set_t
	The aux ID set type definition from IConstAuxStore.
template<class T, class ALLOC = std::allocator<T>>
using	AuxVariable_t = std::vector<T, ALLOC>
	Declare how to wrap variables for this sort of base.

Public Member Functions
	ByteStreamAuxContainer_v1 ()
	Default constructor.
	ByteStreamAuxContainer_v1 (const ByteStreamAuxContainer_v1 &parent)
	Copy constructor.
virtual	~ByteStreamAuxContainer_v1 ()
	Destructor.
ByteStreamAuxContainer_v1 &	operator= (const ByteStreamAuxContainer_v1 &rhs)
	Assignment operator.
void	reset ()
	Function resetting the internal (cached) state of the object.
template<typename T>
auxid_t	getAuxID (const std::string &name, std::vector< T > &, SG::AuxVarFlags flags=SG::AuxVarFlags::None)
	Get the auxiliary ID for one of the persistent variables.
template<typename T>
void	regAuxVar (auxid_t auxid, const std::string &name, std::vector< T > &vec)
	Register one of the user defined 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.
virtual bool	setOption (auxid_t, const AuxDataOption &)
	Set an option for a given auxiliary variable.
virtual IAuxTypeVector *	linkedVector (SG::auxid_t)
virtual const IAuxTypeVector *	linkedVector (SG::auxid_t) const
	Return interface for a linked variable.
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 (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 void *	getDecoration (auxid_t auxid, size_t size, size_t capacity) override
	Get a pointer to a given array, as a decoration.
virtual bool	isDecoration (auxid_t auxid) const override
	Test if a variable is a decoration.
virtual void	lock () override
	Lock the container.
virtual bool	clearDecorations () override
	Clear all decorations.
virtual void	lockDecoration (SG::auxid_t auxid) override
	Lock a decoration.
virtual size_t	size () const override
	Get the size of the container.
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.
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 Member Functions
size_t	size_noLock () const
	Internal method: return size without taking out the lock.
template<typename T>
SG::IAuxTypeVector *	getVector1 (auxid_t auxid, std::map< std::string, std::vector< T > > &pers, size_t size, size_t capacity, bool quiet, bool forDecor) const
	Function retrieving a simple dynamic variable.
SG::IAuxTypeVector *	getVector1 (auxid_t auxid, size_t size, size_t capacity, bool quiet, bool forDecor) const

Private Attributes
std::string	m_name
	Name of the container in memory. Set externally.
Variables persisified into the ByteStream
std::map< std::string, std::vector< int > > m_int	ATLAS_THREAD_SAFE
	Variable holding integer auxiliary variables.
std::map< std::string, std::vector< float > > m_float	ATLAS_THREAD_SAFE
	Variable holding float auxiliary variables.
std::map< std::string, std::vector< std::vector< int > > > m_vecInt	ATLAS_THREAD_SAFE
	Variable holding vector of integer auxiliary variables.
std::map< std::string, std::vector< std::vector< float > > > m_vecFloat	ATLAS_THREAD_SAFE
	Variable holding vector of float auxiliary variables.

Transient variables used to implement the IAuxStore interface
typedef AthContainers_detail::mutex	mutex_t
	Mutex for multithread synchronization.
typedef AthContainers_detail::lock_guard< mutex_t >	guard_t
auxid_set_t m_auxids	ATLAS_THREAD_SAFE
	Internal list of auxiliary variables.
std::vector< SG::IAuxTypeVector * >	m_staticVecs
	Internal list of static managed variables.
std::vector< SG::IAuxTypeVector * > m_dynamicVecs	ATLAS_THREAD_SAFE
	Internal list of dynamic managed variables.
bool	m_locked
	Has the container been locked?
SG::auxid_set_t	m_decorations
	Record which variables are decorations.
mutex_t	m_mutex

Detailed Description

Base class for dynamic auxiliary stores saved into ByteStream.

The point of this class is to behave similarly to xAOD::AuxContainerBase. The trigger developers can develop their specific auxiliary store classes on top of this class. The base class can manage the storage of simple variable types, while the classes inheriting from it need to manage any specific variables that they want to store.

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 37 of file ByteStreamAuxContainer_v1.h.

Member Typedef Documentation

◆ auxid_set_t

typedef SG::auxid_set_t xAOD::ByteStreamAuxContainer_v1::auxid_set_t

The aux ID set type definition from IConstAuxStore.

Definition at line 46 of file ByteStreamAuxContainer_v1.h.

◆ auxid_t

typedef SG::auxid_t xAOD::ByteStreamAuxContainer_v1::auxid_t

The aux ID type definition from IConstAuxStore.

Definition at line 44 of file ByteStreamAuxContainer_v1.h.

◆ AuxVariable_t

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

using xAOD::ByteStreamAuxContainer_v1::AuxVariable_t = std::vector<T, ALLOC>

Declare how to wrap variables for this sort of base.

Definition at line 132 of file ByteStreamAuxContainer_v1.h.

◆ guard_t

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

private

Definition at line 191 of file ByteStreamAuxContainer_v1.h.

◆ mutex_t

typedef AthContainers_detail::mutex xAOD::ByteStreamAuxContainer_v1::mutex_t

private

Mutex for multithread synchronization.

Definition at line 190 of file ByteStreamAuxContainer_v1.h.

Constructor & Destructor Documentation

◆ ByteStreamAuxContainer_v1() [1/2]

xAOD::ByteStreamAuxContainer_v1::ByteStreamAuxContainer_v1 ( )

Default constructor.

Definition at line 19 of file ByteStreamAuxContainer_v1.cxx.

      : SG::IAuxStore(),
        m_int(), m_float(), m_vecInt(), m_vecFloat(),
        m_staticVecs(), m_dynamicVecs(),
        m_locked( false ),
        m_name( "UNKNOWN" ) {
 
   }

◆ ByteStreamAuxContainer_v1() [2/2]

xAOD::ByteStreamAuxContainer_v1::ByteStreamAuxContainer_v1 ( const ByteStreamAuxContainer_v1 & parent )

Copy constructor.

Definition at line 28 of file ByteStreamAuxContainer_v1.cxx.

      : SG::IAuxStore( parent ),
        m_int( parent.m_int ), m_float( parent.m_float ),
        m_vecInt( parent.m_vecInt ), m_vecFloat( parent.m_vecFloat ),
        // The auxiliary IDs are copied:
        m_auxids( parent.m_auxids ),
        // But the internal pointers are not:
        m_staticVecs(),
        m_dynamicVecs(), m_locked( false ),
        m_name( parent.m_name ) {
 
   }

◆ ~ByteStreamAuxContainer_v1()

xAOD::ByteStreamAuxContainer_v1::~ByteStreamAuxContainer_v1 ( )

virtual

Destructor.

Definition at line 42 of file ByteStreamAuxContainer_v1.cxx.

                                                         {
 
      // Clean up the helper objects:
      std::vector< SG::IAuxTypeVector* >::iterator itr = m_dynamicVecs.begin();
      std::vector< SG::IAuxTypeVector* >::iterator end = m_dynamicVecs.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) delete *itr;
      }
      itr = m_staticVecs.begin();
      end = m_staticVecs.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) delete *itr;
      }
   }

Member Function Documentation

◆ clearDecorations()

bool xAOD::ByteStreamAuxContainer_v1::clearDecorations ( )

overridevirtual

Clear all decorations.

Implements SG::IConstAuxStore.

Definition at line 195 of file ByteStreamAuxContainer_v1.cxx.

   {
     guard_t guard (m_mutex);
 
     const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
     bool anycleared = false;
     for (auxid_t auxid : m_decorations) {
       if (m_dynamicVecs[auxid]) {
         delete m_dynamicVecs[auxid];
         m_dynamicVecs[auxid] = nullptr;
         m_auxids.erase( auxid );
         anycleared = true;
 
         const std::string name = r.getName( auxid );
         const std::type_info* ti = r.getType( auxid );
         if (ti == &typeid(int))
           m_int.erase (name);
         else if (ti == &typeid(float))
           m_float.erase (name);
         else if (ti == &typeid(std::vector<int>))
           m_vecInt.erase (name);
         else if (ti == &typeid(std::vector<float>))
           m_vecFloat.erase (name);
       }
     }
     m_decorations.clear();
 
     return anycleared;
   }

◆ getAuxID()

template<typename T>

auxid_t xAOD::ByteStreamAuxContainer_v1::getAuxID	(	const std::string &	name,
		std::vector< T > &	,
		SG::AuxVarFlags	flags = SG::AuxVarFlags::None )

Get the auxiliary ID for one of the persistent variables.

◆ getAuxIDs()

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

overridevirtual

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

Implements SG::IConstAuxStore.

Definition at line 118 of file ByteStreamAuxContainer_v1.cxx.

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

◆ getData() [1/2]

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

overridevirtual

Get a pointer to a given array.

Implements SG::IConstAuxStore.

Definition at line 86 of file ByteStreamAuxContainer_v1.cxx.

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

◆ getData() [2/2]

void * xAOD::ByteStreamAuxContainer_v1::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 260 of file ByteStreamAuxContainer_v1.cxx.

                                                               {
 
      guard_t guard (m_mutex);
 
      // Check if we have such a static variable:
      if( ( auxid < m_staticVecs.size() ) && ( m_staticVecs[ auxid ] ) ) {
         // Set it to the right size:
         m_staticVecs[ auxid ]->reserve( capacity );
         m_staticVecs[ auxid ]->resize( size );
         // We're done already:
         return m_staticVecs[ auxid ]->toPtr();
      }
      // Check if we already know about this dynamic variable:
      else if( ( auxid < m_dynamicVecs.size() ) &&
               ( m_dynamicVecs[ auxid ] ) ) {
         // Set it to the right size:
         m_dynamicVecs[ auxid ]->reserve( capacity );
         m_dynamicVecs[ auxid ]->resize( size );
         // We're done already:
         return m_dynamicVecs[ auxid ]->toPtr();
      }
 
      SG::IAuxTypeVector* v = getVector1 (auxid, size, capacity, false, false);
      if( v ) {
         return v->toPtr();
      }
      return nullptr;
   }

◆ getDecoration()

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

overridevirtual

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

Implements SG::IConstAuxStore.

Definition at line 132 of file ByteStreamAuxContainer_v1.cxx.

   {
      guard_t guard (m_mutex);
 
      // Does this variable already exist?
      void* ret = nullptr;
      if( ( auxid < m_staticVecs.size() ) && ( m_staticVecs[ auxid ] ) ) {
        ret = m_staticVecs[ auxid ]->toPtr();
      }
      // If it's a dynamic one:
      else if( ( auxid < m_dynamicVecs.size() ) &&
               ( m_dynamicVecs[ auxid ] ) ) {
        ret = m_dynamicVecs[ auxid ]->toPtr();
      }
 
      if (!ret) {
        SG::IAuxTypeVector* v = getVector1 (auxid, 0, 0, true, true);
        if( v ) {
           ret = v->toPtr();
        }
      }
 
      if (ret) {
        // Raise exception if locked and not a decoration.
        if (m_locked) {
          if ( ! m_decorations.test (auxid) ) {
            throw SG::ExcStoreLocked (auxid);
          }
        }
        return ret;
      }
 
      // Make a new variable.
      // If locked, mark as a decoration.
      if (m_locked) {
        m_decorations.insert (auxid);
        std::atomic_thread_fence (std::memory_order_seq_cst);
      }
      SG::IAuxTypeVector* v = getVector1 (auxid, size, capacity, false, true);
      if( v ) {
         ret = v->toPtr();
      }
 
      return ret;
   }

◆ getDecorIDs()

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

overridevirtual

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

Implements SG::IConstAuxStore.

Definition at line 125 of file ByteStreamAuxContainer_v1.cxx.

                                                {
 
      // Return the full list of IDs:
      return m_decorations;
   }

◆ getVector()

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

finaloverridevirtual

Return vector interface for one aux data item.

Implements SG::IConstAuxStore.

Definition at line 95 of file ByteStreamAuxContainer_v1.cxx.

                                                                                     {
 
      guard_t guard (m_mutex);
 
      // If it's a static auxiliary property:
      if( ( auxid < m_staticVecs.size() ) && ( m_staticVecs[ auxid ] ) ) {
         // We're done already:
         return m_staticVecs[ auxid ];
      }
      // If it's a dynamic one:
      else if( ( auxid < m_dynamicVecs.size() ) &&
               ( m_dynamicVecs[ auxid ] ) ) {
         // We're done already:
         return m_dynamicVecs[ auxid ];
      }
 
      // Try to retrieve the dynamic variable:
      // quiet on because this method may be called from isAccessible
      // and that shouldn't generate any output.
      return getVector1 (auxid, 0, 0, true, false);
   }

◆ getVector1() [1/2]

SG::IAuxTypeVector * xAOD::ByteStreamAuxContainer_v1::getVector1	(	auxid_t	auxid,
		size_t	size,
		size_t	capacity,
		bool	quiet,
		bool	forDecor ) const

private

Definition at line 537 of file ByteStreamAuxContainer_v1.cxx.

                                                               {
 
      // Private method --- should hold lock before calling this.
 
      if( *( SG::AuxTypeRegistry::instance().getType( auxid ) ) ==
          typeid( int ) ) {
 
         return getVector1( auxid, m_int, size, capacity, quiet, forDecor );
      }
      else if( *( SG::AuxTypeRegistry::instance().getType( auxid ) ) ==
               typeid( float ) ) {
 
         return getVector1( auxid, m_float, size, capacity, quiet, forDecor );
      }
      else if( *( SG::AuxTypeRegistry::instance().getType( auxid ) ) ==
               typeid( std::vector< int > ) ) {
 
         return getVector1( auxid, m_vecInt, size, capacity, quiet, forDecor );
      }
      else if( *( SG::AuxTypeRegistry::instance().getType( auxid ) ) ==
               typeid( std::vector< float > ) ) {
 
         return getVector1( auxid, m_vecFloat, size, capacity, quiet, forDecor );
      }
 
      // The object can't handle this variable type...
      std::cerr << "ERROR xAOD::ByteStreamAuxContainer_v1::getData "
                << "Unknown variable type ("
                << SG::AuxTypeRegistry::instance().getType( auxid )->name()
                << ") requested" << std::endl;
 
      return nullptr;
   }

◆ getVector1() [2/2]

template<typename T>

SG::IAuxTypeVector * xAOD::ByteStreamAuxContainer_v1::getVector1	(	auxid_t	auxid,
		std::map< std::string, std::vector< T > > &	pers,
		size_t	size,
		size_t	capacity,
		bool	quiet,
		bool	forDecor ) const

private

Function retrieving a simple dynamic variable.

Look for variable auxid in pers.

If capacity > 0, a new variable will be created if necessary.

If not found, create it if capacity != 0.

Definition at line 465 of file ByteStreamAuxContainer_v1.cxx.

                                                               {
 
      // Private method --- should hold lock before calling this.
 
      // Look up the name of the variable:
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      const std::string name = r.getName( auxid );
 
      // Try to find the variable:
      typename std::map< std::string, std::vector< T > >::iterator itr =
         pers.find( name );
      if( itr == pers.end() ) {
         // Variable isn't there.  Fail if capacity==0.
         if (capacity == 0) {
           if (!quiet) {
             std::cerr << "ERROR xAOD::ByteStreamAuxContainer_v1::getData (const) "
                       << "Variable with unknown name (" << name << ") requested"
                       << std::endl;
           }
           return nullptr;
         }
 
         if (m_locked && !forDecor)
           throw SG::ExcStoreLocked ("getData");
 
         if (r.isLinked(auxid)) {
             std::cerr << "ERROR xAOD::ByteStreamAuxContainer_v1 doesn't implement linked variables"
                       << std::endl;
           return nullptr;
         }
 
         // Create the variable.
         itr = pers.insert (std::make_pair (name, std::vector<T>())).first;
      }
 
      // Get hold of the variable.
      std::vector< T >& var = itr->second;
 
      // Make sure that the internal vector is big enough:
      if( m_dynamicVecs.size() <= auxid ) {
         m_dynamicVecs.resize( auxid + 1 );
      }
 
      // Just an internal check...
      if( m_dynamicVecs[ auxid ] ) {
         std::cerr << "ERROR xAOD::ByteStreamAuxContainer_v1::getData "
                   << "Internal inconsistency detected!" << std::endl;
         return m_dynamicVecs[ auxid ];
      }
 
      // Register the variable:
      m_dynamicVecs[ auxid ] = new AuxPersVector< T >( auxid, var, false, nullptr );
 
      if (capacity > 0) {
        // Set it to the right size:
        m_dynamicVecs[ auxid ]->reserve( capacity );
        m_dynamicVecs[ auxid ]->resize( size );
      }
 
      // Remember that we are now handling this variable:
      m_auxids.insert( auxid );
 
      // Return the pointer to the array:
      return m_dynamicVecs[ auxid ];
   }

◆ getWritableAuxIDs()

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

overridevirtual

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 291 of file ByteStreamAuxContainer_v1.cxx.

                                                      {
 
      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.

Implemented in SG::AuxStoreInternal.

◆ insertMove() [2/2]

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

overridevirtual

Insert contents of another store via move.

Definition at line 363 of file ByteStreamAuxContainer_v1.cxx.

                                                                               {
 
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "insertMove" );
      }
 
      bool nomove = true;
      size_t other_size = other.size();
 
      SG::auxid_set_t ignore = ignore_in;
 
      // Do the operation on the static variables:
      for (SG::auxid_t id : m_auxids) {
        SG::IAuxTypeVector* v_dst = nullptr;
        if (id < m_dynamicVecs.size())
          v_dst = m_dynamicVecs[id];
        if (!v_dst && id < m_staticVecs.size())
          v_dst = m_staticVecs[id];
        if (v_dst) {
          ignore.insert (id);
          if (other.getData (id)) {
            void* src_ptr = other.getData (id, other_size, other_size);
            if (src_ptr) {
              if (!v_dst->insertMove (pos, src_ptr, 0, other_size,
                                      other))
                nomove = false;
            }
          }
          else {
            const void* orig = v_dst->toPtr();
            v_dst->shift (pos, other_size);
            if (orig != v_dst->toPtr())
              nomove = false;
          }
        }
      }
 
      // Add any new variables not present in the original container.
      for (SG::auxid_t id : other.getAuxIDs()) {
        if (!m_auxids.test(id) &&
            !ignore.test(id))
        {
          if (other.getData (id)) {
            void* src_ptr = other.getData (id, other_size, other_size);
            if (src_ptr) {
              size_t sz = size_noLock();
              getVector1 (id, sz, sz, true, false);
              m_dynamicVecs[id]->resize (sz - other_size);
              (void)m_dynamicVecs[id]->insertMove (pos, src_ptr, 0, other_size,
                                                   other);
              nomove = false;
            }
          }
        }
      }
 
      return nomove;
   }

◆ isDecoration()

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

overridevirtual

Test if a variable is a decoration.

Implements SG::IConstAuxStore.

Definition at line 182 of file ByteStreamAuxContainer_v1.cxx.

   {
      guard_t guard (m_mutex);
      return m_locked && m_decorations.test (auxid);
   }

◆ linkedVector() [1/2]

virtual IAuxTypeVector * SG::IAuxStore::linkedVector ( SG::auxid_t )

inlinevirtualinherited

Reimplemented in SG::AuxStoreInternal, xAOD::AuxContainerBase, xAOD::AuxInfoBase, and xAOD::details::AuxStoreBase.

Definition at line 187 of file IAuxStore.h.

188 { return nullptr; }

◆ linkedVector() [2/2]

virtual const IAuxTypeVector * SG::IConstAuxStore::linkedVector ( SG::auxid_t ) const

inlinevirtualinherited

Return interface for a linked variable.

Parameters

auxid The ID of the parent variable.

If auxid has a linked variable, then return the IAuxTypeVector describing it. Otherwise, return nullptr. May return nullptr unconditionally if this store does not support linked variables.

Reimplemented from SG::IConstAuxStore.

Definition at line 189 of file IConstAuxStore.h.

190 { return nullptr; }

◆ lock()

void xAOD::ByteStreamAuxContainer_v1::lock ( )

overridevirtual

Lock the container.

Implements SG::IConstAuxStore.

Definition at line 189 of file ByteStreamAuxContainer_v1.cxx.

   {
       guard_t guard (m_mutex);
       m_locked = true;
   }

◆ lockDecoration()

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

overridevirtual

Lock a decoration.

Implements SG::IConstAuxStore.

Definition at line 228 of file ByteStreamAuxContainer_v1.cxx.

   { 
     guard_t guard (m_mutex);
     m_decorations.reset (auxid);
   }

◆ name()

const char * xAOD::ByteStreamAuxContainer_v1::name ( ) const

Get the name of the container instance.

Definition at line 450 of file ByteStreamAuxContainer_v1.cxx.

                                                     {
 
      return m_name.c_str();
   }

◆ operator=()

ByteStreamAuxContainer_v1 & xAOD::ByteStreamAuxContainer_v1::operator= ( const ByteStreamAuxContainer_v1 & rhs )

Assignment operator.

Definition at line 58 of file ByteStreamAuxContainer_v1.cxx.

                                                     {
 
      if (this != &rhs) {
        // Copy the persistent variables:
        m_int      = rhs.m_int;
        m_float    = rhs.m_float;
        m_vecInt   = rhs.m_vecInt;
        m_vecFloat = rhs.m_vecFloat;
 
        // Also copy the list of auxiliary IDs handled:
        m_auxids        = rhs.m_auxids;
 
        // The static variables should be left alone. Those should still
        // point to the correct places in memory. But the dynamic variables
        // need to be cleared out. Those will be re-created when/if needed.
        for( auto* ptr : m_dynamicVecs ) {
           delete ptr;
        }
        m_dynamicVecs.clear();
 
        // Copy the container's name:
        m_name = rhs.m_name;
      }
 
      return *this;
   }

◆ regAuxVar()

template<typename T>

void xAOD::ByteStreamAuxContainer_v1::regAuxVar	(	auxid_t	auxid,
		const std::string &	name,
		std::vector< T > &	vec )

Register one of the user defined persistent variables internally.

◆ reserve()

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

overridevirtual

Reserve a given size for the arrays.

Implements SG::IAuxStore.

Definition at line 321 of file ByteStreamAuxContainer_v1.cxx.

                                                        {
 
      guard_t guard (m_mutex);
 
      if (m_locked)
        throw SG::ExcStoreLocked ("reserve");
 
      std::vector< SG::IAuxTypeVector* >::iterator itr = m_dynamicVecs.begin();
      std::vector< SG::IAuxTypeVector* >::iterator end = m_dynamicVecs.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) ( *itr )->reserve( size );
      }
      itr = m_staticVecs.begin();
      end = m_staticVecs.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) ( *itr )->reserve( size );
      }
 
      return;
   }

◆ reset()

void xAOD::ByteStreamAuxContainer_v1::reset ( )

Function resetting the internal (cached) state of the object.

Definition at line 428 of file ByteStreamAuxContainer_v1.cxx.

                                         {
 
      guard_t guard (m_mutex);
 
      for (SG::IAuxTypeVector* p : m_dynamicVecs)
         delete p;
      m_dynamicVecs.clear();
 
      SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
#define ADD_IDS(VAR, TYP) \
      do { typedef std::map< std::string, std::vector< TYP > > CONT; \
          for (CONT::value_type& p : VAR)                                 \
             m_auxids.insert (r.getAuxID< TYP > (p.first, "", SG::AuxVarFlags::SkipNameCheck)); } while(0)
      ADD_IDS(m_int, int);
      ADD_IDS(m_float, float);
      ADD_IDS(m_vecInt, std::vector<int>);
      ADD_IDS(m_vecFloat, std::vector<float>);
#undef ADD_IDS
 
      return;
   }

◆ resize()

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

overridevirtual

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 296 of file ByteStreamAuxContainer_v1.cxx.

                                                       {
 
      guard_t guard (m_mutex);
 
      if (m_locked)
        throw SG::ExcStoreLocked ("resize");
 
      bool nomoves = true;
      for (SG::IAuxTypeVector* v : m_dynamicVecs) {
         if(v) {
           if (!v->resize( size ))
             nomoves = false;
         }
      }
 
      for (SG::IAuxTypeVector* v : m_staticVecs) {
         if(v) {
           if (!v->resize( size ))
             nomoves = false;
         }
      }
 
      return nomoves;
   }

◆ setName()

void xAOD::ByteStreamAuxContainer_v1::setName ( const char * name )

Set the name of the container instance.

Definition at line 455 of file ByteStreamAuxContainer_v1.cxx.

                                                             {
 
      m_name = name;
      return;
   }

◆ setOption()

virtual bool SG::IAuxStore::setOption	(	auxid_t	,
		const AuxDataOption &	)

inlinevirtualinherited

Set an option for a given auxiliary variable.

Parameters

auxid	The identifier of the desired aux data item.
option	The option to set.

The interpretation of the option depends on the particular representation of the variable.

Returns true if the option setting was successful; false otherwise.

Reimplemented in SG::AuxStoreInternal, xAOD::AuxContainerBase, and xAOD::AuxInfoBase.

Definition at line 173 of file IAuxStore.h.

174 { return false; }

◆ shift()

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

overridevirtual

Shift the contents of the stored arrays.

Implements SG::IAuxStore.

Definition at line 342 of file ByteStreamAuxContainer_v1.cxx.

                                                                     {
 
      guard_t guard (m_mutex);
 
      if (m_locked)
        throw SG::ExcStoreLocked ("shift");
 
      std::vector< SG::IAuxTypeVector* >::iterator itr = m_dynamicVecs.begin();
      std::vector< SG::IAuxTypeVector* >::iterator end = m_dynamicVecs.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) ( *itr )->shift( pos, offs );
      }
      itr = m_staticVecs.begin();
      end = m_staticVecs.end();
      for( ; itr != end; ++itr ) {
         if( *itr ) ( *itr )->shift( pos, offs );
      }
 
      return;
   }

◆ size()

size_t xAOD::ByteStreamAuxContainer_v1::size ( ) const

overridevirtual

Get the size of the container.

Implements SG::IConstAuxStore.

Definition at line 253 of file ByteStreamAuxContainer_v1.cxx.

   {
     guard_t guard (m_mutex);
     return size_noLock();
   }

◆ size_noLock()

size_t xAOD::ByteStreamAuxContainer_v1::size_noLock ( ) const

private

Internal method: return size without taking out the lock.

Definition at line 235 of file ByteStreamAuxContainer_v1.cxx.

   {
     for (SG::auxid_t i : m_auxids) {
       if (i < m_staticVecs.size() && m_staticVecs[i]) {
         size_t sz = m_staticVecs[i]->size();
         if (sz > 0)
           return sz;
       }
       if (i < m_dynamicVecs.size() && m_dynamicVecs[i]) {
         size_t sz = m_dynamicVecs[i]->size();
         if (sz > 0)
           return sz;
       }
     }
 
     return 0;
   }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/6]

std::map< std::string, std::vector< int > > m_int xAOD::ByteStreamAuxContainer_v1::ATLAS_THREAD_SAFE

mutableprivate

Variable holding integer auxiliary variables.

Definition at line 165 of file ByteStreamAuxContainer_v1.h.

◆ ATLAS_THREAD_SAFE [2/6]

std::map< std::string, std::vector< float > > m_float xAOD::ByteStreamAuxContainer_v1::ATLAS_THREAD_SAFE

mutableprivate

Variable holding float auxiliary variables.

Definition at line 167 of file ByteStreamAuxContainer_v1.h.

◆ ATLAS_THREAD_SAFE [3/6]

std::map< std::string, std::vector< std::vector< int > > > m_vecInt xAOD::ByteStreamAuxContainer_v1::ATLAS_THREAD_SAFE

mutableprivate

Variable holding vector of integer auxiliary variables.

Definition at line 169 of file ByteStreamAuxContainer_v1.h.

◆ ATLAS_THREAD_SAFE [4/6]

std::map< std::string, std::vector< std::vector< float > > > m_vecFloat xAOD::ByteStreamAuxContainer_v1::ATLAS_THREAD_SAFE

mutableprivate

Variable holding vector of float auxiliary variables.

Definition at line 171 of file ByteStreamAuxContainer_v1.h.

◆ ATLAS_THREAD_SAFE [5/6]

auxid_set_t m_auxids xAOD::ByteStreamAuxContainer_v1::ATLAS_THREAD_SAFE

mutableprivate

Internal list of auxiliary variables.

Definition at line 179 of file ByteStreamAuxContainer_v1.h.

◆ ATLAS_THREAD_SAFE [6/6]

std::vector< SG::IAuxTypeVector* > m_dynamicVecs xAOD::ByteStreamAuxContainer_v1::ATLAS_THREAD_SAFE

mutableprivate

Internal list of dynamic managed variables.

Definition at line 183 of file ByteStreamAuxContainer_v1.h.

◆ m_decorations

SG::auxid_set_t xAOD::ByteStreamAuxContainer_v1::m_decorations

private

Record which variables are decorations.

Definition at line 187 of file ByteStreamAuxContainer_v1.h.

◆ m_locked

bool xAOD::ByteStreamAuxContainer_v1::m_locked

private

Has the container been locked?

Definition at line 185 of file ByteStreamAuxContainer_v1.h.

◆ m_mutex

mutex_t xAOD::ByteStreamAuxContainer_v1::m_mutex

mutableprivate

Definition at line 192 of file ByteStreamAuxContainer_v1.h.

◆ m_name

std::string xAOD::ByteStreamAuxContainer_v1::m_name

private

Name of the container in memory. Set externally.

Definition at line 197 of file ByteStreamAuxContainer_v1.h.

◆ m_staticVecs

std::vector< SG::IAuxTypeVector* > xAOD::ByteStreamAuxContainer_v1::m_staticVecs

private

Internal list of static managed variables.

Definition at line 181 of file ByteStreamAuxContainer_v1.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 199 of file IAuxStore.h.

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

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Transient variables used to implement the IAuxStore interface

Detailed Description

Member Typedef Documentation

◆ auxid_set_t

◆ auxid_t

◆ AuxVariable_t

◆ guard_t

◆ mutex_t

Constructor & Destructor Documentation

◆ ByteStreamAuxContainer_v1() [1/2]

◆ ByteStreamAuxContainer_v1() [2/2]

◆ ~ByteStreamAuxContainer_v1()

Member Function Documentation

◆ clearDecorations()

◆ getAuxID()

◆ getAuxIDs()

◆ getData() [1/2]

◆ getData() [2/2]

◆ getDecoration()

◆ getDecorIDs()

◆ getVector()

◆ getVector1() [1/2]

◆ getVector1() [2/2]

◆ getWritableAuxIDs()

◆ insertMove() [1/2]

◆ insertMove() [2/2]

◆ isDecoration()

◆ linkedVector() [1/2]

◆ linkedVector() [2/2]

◆ lock()

◆ lockDecoration()

◆ name()

◆ operator=()

◆ regAuxVar()

◆ reserve()

◆ reset()

◆ resize()

◆ setName()

◆ setOption()

◆ shift()

◆ size()

◆ size_noLock()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/6]

◆ ATLAS_THREAD_SAFE [2/6]

◆ ATLAS_THREAD_SAFE [3/6]

◆ ATLAS_THREAD_SAFE [4/6]

◆ ATLAS_THREAD_SAFE [5/6]

◆ ATLAS_THREAD_SAFE [6/6]

◆ m_decorations

◆ m_locked

◆ m_mutex

◆ m_name

◆ m_staticVecs

◆ supportsThinning