xAOD::ShallowAuxContainer Class Reference

Class creating a shallow copy of an existing auxiliary container. More...

#include <ShallowAuxContainer.h>

Inheritance diagram for xAOD::ShallowAuxContainer:

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.
enum	AuxStoreType { AST_ObjectStore = 0 , AST_ContainerStore = 1 }
	Type of the auxiliary store. More...

Public Member Functions
	ShallowAuxContainer (bool standalone=false)
	Default constructor.
	ShallowAuxContainer (const ShallowAuxContainer &parent)
	Copy constructor.
	ShallowAuxContainer (const DataLink< SG::IConstAuxStore > &parent, bool standalone=false)
	Constructor with a parent object.
	~ShallowAuxContainer ()
	Destructor.
ShallowAuxContainer &	operator= (const ShallowAuxContainer &rhs)
	Assignment operator.
const DataLink< SG::IConstAuxStore > &	parent () const
	Get the parent store.
void	setParent (const DataLink< SG::IConstAuxStore > &link)
	Set the parent store.
bool	shallowIO () const
	Check whether only the overriden parameters will be written out or not.
void	setShallowIO (bool value)
	Set whether only the overriden parameters should be written out.
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)
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
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
	Return the data vector for one aux data decoration item.
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.
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 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::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 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::recursive_mutex	mutex_t
	Mutex for multithread synchronization.
typedef AthContainers_detail::lock_guard< mutex_t >	guard_t

Private Member Functions
void	remakeAuxIDs () const

Private Attributes
AuxSelection	m_selection
	Dynamic attributes selection implementation.
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
	Flag keeping track of whether this object is locked or not.
DataLink< SG::IConstAuxStore >	m_parentLink
	Link to the parent object.
const SG::IAuxStoreIO *	m_parentIO
	Optional pointer to the IO interface of the parent object.
bool	m_shallowIO
	Flag for whether to do "shallow IO" or not.
mutex_t	m_mutex
auxid_set_t m_auxids	ATLAS_THREAD_SAFE
auxid_set_t m_decorids	ATLAS_THREAD_SAFE
bool m_auxidsValid	ATLAS_THREAD_SAFE
std::string	m_name
	Name of the container in memory. Set externally.

Detailed Description

Class creating a shallow copy of an existing auxiliary container.

During analysis, in order to create objects that override just some of the properties of an original, it's wasteful to make full copies of the objects. Not to mention that the full copies have generally issues with dynamic variables.

The behaviour of this class is that it takes all the properties that it doesn't know about from the parent auxiliary store, but the ones that it has an override for, it provides itself.

The object is persistifiable. The user can choose whether to only write out the variables that were modified wrt. the original container, or possibly all the variables. (In case the original container is not getting written out.)

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

Member Typedef Documentation

auxid_set_t

typedef SG::auxid_set_t xAOD::ShallowAuxContainer::auxid_set_t

The aux ID set type definition.

Definition at line 56 of file ShallowAuxContainer.h.

auxid_t

typedef SG::auxid_t xAOD::ShallowAuxContainer::auxid_t

The aux ID type definition.

Definition at line 54 of file ShallowAuxContainer.h.

guard_t

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

private

Definition at line 206 of file ShallowAuxContainer.h.

mutex_t

typedef AthContainers_detail::recursive_mutex xAOD::ShallowAuxContainer::mutex_t

private

Mutex for multithread synchronization.

Definition at line 205 of file ShallowAuxContainer.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

ShallowAuxContainer() [1/3]

xAOD::ShallowAuxContainer::ShallowAuxContainer

(

bool

standalone = false

)

Default constructor.

Parameters

standalone

true if the store will be used for a standalone object, false for a container

Definition at line 33 of file ShallowAuxContainer.cxx.

      : m_selection(),
        m_store( new SG::AuxStoreInternal( standalone ) ),
        m_storeIO( nullptr ), m_ownsStore( true ), m_locked( false ),
        m_parentLink(), m_parentIO( nullptr ), m_shallowIO( true ),
        m_auxids (),
        m_auxidsValid (false),
        m_name( "UNKNOWN" ) {
 
      m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
   }

ShallowAuxContainer() [2/3]

xAOD::ShallowAuxContainer::ShallowAuxContainer

(

const ShallowAuxContainer &

parent

)

Copy constructor.

Definition at line 45 of file ShallowAuxContainer.cxx.

      : SG::IAuxStore(), SG::IAuxStoreIO(), SG::IAuxStoreHolder(),
        m_ownsStore( false ),
        m_auxids (),
        m_auxidsValid (false)
   {
      // Keep the source unmutable during copy
      guard_t guard( parent.m_mutex );
      // cppcheck-suppress copyCtorPointerCopying
      m_store = parent.m_store;
      m_storeIO = parent.m_storeIO;
      m_locked = parent.m_locked;
      m_parentLink = parent.m_parentLink;
      m_parentIO = parent.m_parentIO;
      m_shallowIO = parent.m_shallowIO;
      m_selection = parent.m_selection;
      m_name = parent.m_name;
   }

ShallowAuxContainer() [3/3]

xAOD::ShallowAuxContainer::ShallowAuxContainer	(	const DataLink< SG::IConstAuxStore > &	parent,
		bool	standalone = false )

Constructor with a parent object.

Parameters

parent	The parent object to make a shallow copy of
standalone	true if the store will be used for a standalone object, false for a container

Definition at line 68 of file ShallowAuxContainer.cxx.

      : m_selection(),
        m_store( new SG::AuxStoreInternal( standalone ) ),
        m_storeIO( nullptr ), m_ownsStore( true ), m_locked( false ),
        m_parentLink( parent ), m_parentIO( nullptr ), m_shallowIO( true ),
        m_auxids (),
        m_auxidsValid (false),
        m_name( "UNKNOWN" ) {
 
      m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
      m_parentIO = dynamic_cast< const SG::IAuxStoreIO* >( m_parentLink.cptr() );
   }

~ShallowAuxContainer()

xAOD::ShallowAuxContainer::~ShallowAuxContainer

(

)

Destructor.

Definition at line 83 of file ShallowAuxContainer.cxx.

                                             {
 
      if( m_ownsStore && m_store ) {
         delete m_store;
      }
   }

Member Function Documentation

clearDecorations()

bool xAOD::ShallowAuxContainer::clearDecorations ( )

overridevirtual

Clear all decorations.

Definition at line 385 of file ShallowAuxContainer.cxx.

   {
     guard_t guard (m_mutex);
     bool ret = m_store->clearDecorations();
     if (ret) {
       remakeAuxIDs();
     }
     return ret;
   }

getAuxIDs()

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

overridevirtual

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

Definition at line 233 of file ShallowAuxContainer.cxx.

                                        {
 
      guard_t guard( m_mutex );
      if (!m_auxidsValid) {
        remakeAuxIDs();
      }
      return m_auxids;
   }

getCopyIDs()

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

overridevirtual

Get the set of variables that we should deep copy.

Definition at line 252 of file ShallowAuxContainer.cxx.

   {
     guard_t guard( m_mutex );
     auxid_set_t ids;
     if( m_parentLink.isValid() ) {
       ids.insert (m_parentLink->getCopyIDs (warnUnlocked));
     }
     ids.insert (m_store->getCopyIDs (warnUnlocked));
     return ids;
   }

getData() [1/2]

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

overridevirtual

Get a pointer to a given array.

Definition at line 193 of file ShallowAuxContainer.cxx.

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

getData() [2/2]

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

                                                         {
 
      guard_t guard (m_mutex);
 
      // Check if we already have this variable by any chance.
      const void* cptr = m_store->getData( auxid );
 
      // Create the variable in the dynamic store:
      void* ptr = m_store->getData( auxid, size, capacity );
 
      // If in some weird way we already had this variable before, then don't
      // try to overwrite it with the parent's payload, and finish here already.
      if( cptr != nullptr ) {
         return ptr;
      }
 
      remakeAuxIDs();
 
      // If the parent doesn't have this variable, then we're done already:
      if( ! m_parentLink.isValid() ) {
         return ptr;
      }
      const void* pptr = m_parentLink->getData( auxid );
      if( ! pptr ) {
         return ptr;
      }
 
      // If the variable does exist in the parent, then copy it over to this
      // store before returning.
 
      // Get the registry:
      SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
 
      // Get the type of this variable:
      const std::type_info* type = reg.getType( auxid );
      if( type == nullptr ) {
         throw std::runtime_error( std::format( "Couldn't find the type of auxiliary ID {}", auxid ) );
      }
 
      // And the allocator type for this variable.
      const std::type_info* allocType = reg.getAllocType( auxid );
      if( allocType == nullptr ) {
         throw std::runtime_error( std::format( "Couldn't find the allocator type of auxiliary ID {}", auxid ) );
      }
 
      // First let's get the vector factory of this variable:
      const SG::IAuxTypeVectorFactory* factory =
        SG::AuxTypeRegistry::instance().getFactory( *type, *allocType );
      if( factory == nullptr ) {
         throw std::runtime_error( std::format( "Couldn't find a factory for type {}", type->name() ) );
      }
 
      // Copy each element of the parent's decoration:
      factory->copy( auxid,
                     SG::AuxVectorInterface( *this ), 0,
                     SG::AuxVectorInterface( *m_parentLink ), 0, size );
 
      // Now we're done:
      return ptr;
   }

getDecoration()

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

overridevirtual

Return the data vector for one aux data decoration item.

Definition at line 275 of file ShallowAuxContainer.cxx.

                                                               {
 
      guard_t guard( m_mutex );
 
      // Check if we already have this variable by any chance.
      const void* cptr = m_store->getData( auxid );
 
      // If the parent has such a variable, then we need to check one more
      // thing. If it's a decoration on the parent, then we should be allowed
      // to override it in this (possibly locked) shallow copy. But let's leave
      // the logic of this up to the parent.
      if( m_locked && m_parentLink.isValid() &&
          ( m_parentLink->getAuxIDs().count( auxid ) > 0 ) )
      {
        if (!m_parentLink->isDecoration (auxid)) {
          throw SG::ExcStoreLocked (auxid);
        }
      }
 
      // If we got this far without any exception, then let the internal store
      // try to provide the decoration for us:
      const size_t nids = m_store->getAuxIDs().size();
      void* result = m_store->getDecoration( auxid, size, capacity );
      if( result && ( nids != m_store->getAuxIDs().size() ) ) {
         remakeAuxIDs();
      }
 
      // If we already had this variable before, then don't try to overwrite it
      // with the parent's payload, and finish here already.
      if( cptr != nullptr ) {
         return result;
      }
 
      // If the parent doesn't have this variable, then we're done.
      if( ! m_parentLink.isValid() ) {
         return result;
      }
      const void* pptr = m_parentLink->getData( auxid );
      if( pptr == nullptr ) {
         return result;
      }
 
      // If the variable does exist in the parent, then copy it over to this
      // store before returning.
 
      // Get the registry.
      SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
 
      // Get the type of this variable.
      const std::type_info* type = reg.getType( auxid );
      if( type == nullptr ) {
         throw std::runtime_error( std::format( "Couldn't find the type of auxiliary ID {}", auxid ) );
      }
 
      // And the allocator type for this variable.
      const std::type_info* allocType = reg.getAllocType( auxid );
      if( allocType == nullptr ) {
         throw std::runtime_error( std::format( "Couldn't find the allocator type of auxiliary ID {}", auxid ) );
      }
 
      // Get the vector factory of this variable.
      const SG::IAuxTypeVectorFactory* factory =
         SG::AuxTypeRegistry::instance().getFactory( *type, *allocType );
      if( factory == nullptr ) {
         throw std::runtime_error( std::format( "Couldn't find a factory for type {}", type->name() ) );
      }
 
      // Copy each element of the parent's decoration.
      factory->copy( auxid,
                     SG::AuxVectorInterface( *this ), 0,
                     SG::AuxVectorInterface( *m_parentLink ), 0, size );
 
      // Now we're done.
      return result;
   }

getDecorIDs()

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

overridevirtual

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

Definition at line 243 of file ShallowAuxContainer.cxx.

                                          {
 
      guard_t guard( m_mutex );
      if (!m_auxidsValid) {
        remakeAuxIDs();
      }
      return m_decorids;
   }

getDynamicAuxIDs()

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

overridevirtual

Get the types(names) of variables created dynamically.

Implements SG::IAuxStoreIO.

Definition at line 572 of file ShallowAuxContainer.cxx.

                                               {
 
      if( m_shallowIO ) {
         if( m_storeIO ) {
            return m_store->getAuxIDs();
         } else {
            static const auxid_set_t dummy (0);
            return dummy;
         }
      } else {
         return getAuxIDs();
      }
   }

getIOData()

const void * xAOD::ShallowAuxContainer::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 521 of file ShallowAuxContainer.cxx.

                                                                   {
 
      guard_t guard (m_mutex);
      // Do we have it?
      if( m_storeIO && m_store->getAuxIDs().test (auxid)) {
         return m_storeIO->getIOData( auxid );
      }
 
      // Do we have a parent that has it?
      const SG::IAuxStoreIO* parentIO = m_parentIO;
      if( ( parentIO == nullptr ) && m_parentLink.isValid() ) {
         parentIO =
            dynamic_cast< const SG::IAuxStoreIO* >( m_parentLink.cptr() );
      }
      if( parentIO ) {
        return parentIO->getIOData( auxid );
      }
 
      // If not, then where did this variable come from?!?
      std::println( std::cerr, "ERROR xAOD::ShallowAuxContainer::getIOData Unknown "
                    "variable ({}) requested",
                    SG::AuxTypeRegistry::instance().getName( auxid ) );
      return nullptr;
   }

getIOType()

const std::type_info * xAOD::ShallowAuxContainer::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 546 of file ShallowAuxContainer.cxx.

                                                                           {
 
      guard_t guard (m_mutex);
      // Do we have it?
      if( m_storeIO && m_store->getAuxIDs().test (auxid)) {
         return m_storeIO->getIOType( auxid );
      }
 
      // Do we have a parent that has it?
      const SG::IAuxStoreIO* parentIO = m_parentIO;
      if( ( parentIO == nullptr ) && m_parentLink.isValid() ) {
         parentIO =
            dynamic_cast< const SG::IAuxStoreIO* >( m_parentLink.cptr() );
      }
      if( parentIO ) {
        return parentIO->getIOType( auxid );
      }
 
      // If not, then where did this variable come from?!?
      std::println( std::cerr, "ERROR xAOD::ShallowAuxContainer::getIOType Unknown "
                    "variable ({}) requested",
                    SG::AuxTypeRegistry::instance().getName( auxid ) );
      return nullptr;
   }

getSelectedAuxIDs()

ShallowAuxContainer::auxid_set_t xAOD::ShallowAuxContainer::getSelectedAuxIDs ( ) const

overridevirtual

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

Reimplemented from SG::IAuxStoreIO.

Definition at line 587 of file ShallowAuxContainer.cxx.

                                                {
 
      if( m_shallowIO ) {
         if( m_storeIO ) {
            return m_selection.getSelectedAuxIDs( m_store->getAuxIDs() );
         } else {
            return auxid_set_t();
         }
      } else {
         return m_selection.getSelectedAuxIDs( getAuxIDs() );
      }
   }

getStore() [1/2]

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

overridevirtual

Implements SG::IAuxStoreHolder.

Definition at line 160 of file ShallowAuxContainer.cxx.

   {
      return m_store;
   }

getStore() [2/2]

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

overridevirtual

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 155 of file ShallowAuxContainer.cxx.

   {
      return m_store;
   }

getStoreType()

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

inlineoverridevirtual

Return the type of the store object.

Implements SG::IAuxStoreHolder.

Reimplemented in xAOD::ShallowAuxInfo.

Definition at line 90 of file ShallowAuxContainer.h.

{ return AST_ContainerStore; }

getVector()

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

finaloverridevirtual

Return vector interface for one aux data item.

Definition at line 202 of file ShallowAuxContainer.cxx.

                                                                               {
 
      guard_t guard( m_mutex );
 
      // Check if we have this variable ourselves. I use getData(...)
      // instead of getAuxIDs(), as a dynamic store may not have connected
      // to all the variables yet that it has available...
      size_t nids = m_store->getAuxIDs().size();
      const SG::IAuxTypeVector* result = m_store->getVector( auxid );
      if( result != nullptr && result->toPtr() != nullptr ) {
         if( nids != m_store->getAuxIDs().size() ) {
            remakeAuxIDs();
         }
         return result;
      }
 
      // If not, then leave it up to the parent object do deal with this:
      if( m_parentLink.isValid() ) {
         nids = m_parentLink->getAuxIDs().size();
         result = m_parentLink->getVector( auxid );
         if( result && ( nids != m_parentLink->getAuxIDs().size() ) ) {
            remakeAuxIDs();
         }
         return result;
      }
 
      // Apparently the variable wasn't found:
      return nullptr;
   }

getWritableAuxIDs()

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

overridevirtual

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 467 of file ShallowAuxContainer.cxx.

                                                {
 
      // Only the variables in the dynamic store are writable. Maybe not
      // even all of those...
      return m_store->getWritableAuxIDs();
   }

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::ShallowAuxContainer::insertMove ( size_t pos, IAuxStore & other, const SG::auxid_set_t & ignore )

overridevirtual

Insert contents of another store via move.

Definition at line 498 of file ShallowAuxContainer.cxx.

                                                                 {
 
      // Nope, not allowed...
      throw std::runtime_error( "Trying to call insertMove on a shallow copy "
                                "container" );
   }

isDecoration()

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

overridevirtual

Test if a variable is a decoration.

Definition at line 263 of file ShallowAuxContainer.cxx.

   {
     guard_t guard( m_mutex );
     if (m_parentLink.isValid()) {
       if (m_parentLink->isDecoration (auxid)) {
         return true;
       }
     }
     return m_store->isDecoration (auxid);
   }

linkedVector()

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

inlinevirtualinherited

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

Definition at line 203 of file IAuxStore.h.

  { return nullptr; }

lock()

void xAOD::ShallowAuxContainer::lock ( )

overridevirtual

Lock the container.

Definition at line 355 of file ShallowAuxContainer.cxx.

   {
     guard_t guard (m_mutex);
     m_locked = true;
     m_store->lock();
   }

lockDecoration()

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

overridevirtual

Lock a decoration.

Definition at line 364 of file ShallowAuxContainer.cxx.

   {
     guard_t guard (m_mutex);
     m_store->lockDecoration (auxid);
     m_auxidsValid = false;
   }

name()

const char * xAOD::ShallowAuxContainer::name

(

)

const

Get the name of the container instance.

Definition at line 604 of file ShallowAuxContainer.cxx.

                                               {
 
      return m_name.c_str();
   }

operator=()

ShallowAuxContainer & xAOD::ShallowAuxContainer::operator=

(

const ShallowAuxContainer &

rhs

)

Assignment operator.

Definition at line 91 of file ShallowAuxContainer.cxx.

                                                                 {
 
      // Check if anything needs to be done:
      if( this == &rhs ) {
         return *this;
      }
 
      // Keep the source unmutable during copy
      std::scoped_lock  lck{m_mutex, rhs.m_mutex};
 
      // Clean up if necessary:
      if( m_ownsStore && m_store ) {
         delete m_store;
         m_store = nullptr;
      }
 
      m_selection  = rhs.m_selection;
      m_ownsStore  = false;
      m_store      = rhs.m_store;
      m_storeIO    = rhs.m_storeIO;
      m_locked     = rhs.m_locked;
      m_parentLink = rhs.m_parentLink;
      m_parentIO   = rhs.m_parentIO;
      m_shallowIO  = rhs.m_shallowIO;
      m_name       = rhs.m_name;
      m_auxids     = rhs.m_auxids;
      m_auxidsValid= rhs.m_auxidsValid;
 
      // Return this object:
      return *this;
   }

parent()

const DataLink< SG::IConstAuxStore > & xAOD::ShallowAuxContainer::parent

(

)

const

Get the parent store.

Definition at line 123 of file ShallowAuxContainer.cxx.

                                                                         {
 
      return m_parentLink;
   }

remakeAuxIDs()

void xAOD::ShallowAuxContainer::remakeAuxIDs ( ) const

private

Definition at line 615 of file ShallowAuxContainer.cxx.

                                                {
     auxid_set_t ids = m_store->getAuxIDs();
     if( m_parentLink.isValid() ) {
       ids.insert (m_parentLink->getAuxIDs());
     }
 
     auxid_set_t decors = m_store->getDecorIDs();
     if( m_parentLink.isValid() ) {
       ids.insert (m_parentLink->getDecorIDs());
     }
 
     // Move assignment no longer clears garbage for the LHS.
     // To limit the buildup of garbage, we do this assignment operation
     // via copy it it will fit, only doing a move in the case where
     // the table would need to be expanded (and we would thus generate
     // garbage anyway).  This is a non-atomic update, but that
     // shouldn't matter for our purposes here.
     if (decors.capacity() > m_decorids.capacity())
       m_decorids = std::move(decors);
     else
       m_decorids = decors;
 
     // Ensure that decoration updates are visible to other threads before
     // auxid updates.
     std::atomic_thread_fence( std::memory_order_seq_cst );
 
     if (ids.capacity() > m_auxids.capacity())
       m_auxids = std::move(ids);
     else
       m_auxids = ids;
 
     m_auxidsValid = true;
   }

reserve()

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

overridevirtual

Reserve a given size for the arrays.

Implements SG::IAuxStore.

Definition at line 484 of file ShallowAuxContainer.cxx.

                                               {
 
      // Nope, not allowed...
      throw std::runtime_error( "Trying to call reserve on a shallow copy "
                                "container" );
   }

resize()

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

overridevirtual

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 474 of file ShallowAuxContainer.cxx.

   {
       if (size == this->size()) {
         return false;
       }
      // Nope, not allowed...
      throw std::runtime_error( "Trying to call resize on a shallow copy "
                                "container" );
   }

setName()

void xAOD::ShallowAuxContainer::setName

(

const char *

name

)

Set the name of the container instance.

Definition at line 609 of file ShallowAuxContainer.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 xAOD::AuxContainerBase, and xAOD::AuxInfoBase.

Definition at line 189 of file IAuxStore.h.

  { return false; }

setParent()

void xAOD::ShallowAuxContainer::setParent

(

const DataLink< SG::IConstAuxStore > &

link

)

Set the parent store.

Definition at line 128 of file ShallowAuxContainer.cxx.

                                                         {
 
      guard_t guard (m_mutex);
      m_parentLink = link;
      m_parentIO = dynamic_cast< const SG::IAuxStoreIO* >( m_parentLink.cptr() );
      m_auxidsValid = false;
      return;
   }

setShallowIO()

void xAOD::ShallowAuxContainer::setShallowIO

(

bool

value

)

Set whether only the overriden parameters should be written out.

Definition at line 143 of file ShallowAuxContainer.cxx.

                                                      {
 
      guard_t guard (m_mutex);
      m_shallowIO = value;
      return;
   }

setStore()

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

overridevirtual

Set a different internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 165 of file ShallowAuxContainer.cxx.

                                                          {
 
      // Check if anything needs to be done:
      guard_t guard (m_mutex);
      if( store == m_store ) return;
 
      if( m_ownsStore && m_store ) {
         delete m_store;
         m_store = nullptr;
      }
 
      // Do the assignment:
      m_store = store;
      m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
      m_ownsStore = true;
      m_auxidsValid = false;
 
      return;
   }

shallowIO()

bool xAOD::ShallowAuxContainer::shallowIO

(

)

const

Check whether only the overriden parameters will be written out or not.

Definition at line 138 of file ShallowAuxContainer.cxx.

                                             {
 
      return m_shallowIO;
   }

shift()

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

overridevirtual

Shift the contents of the stored arrays.

Implements SG::IAuxStore.

Definition at line 491 of file ShallowAuxContainer.cxx.

                                                          {
 
      // Nope, not allowed...
      throw std::runtime_error( "Trying to call shift on a shallow copy "
                                "container" );
   }

size()

size_t xAOD::ShallowAuxContainer::size ( ) const

overridevirtual

Get the size of the container.

Definition at line 371 of file ShallowAuxContainer.cxx.

                                          {
 
      guard_t guard( m_mutex );
      size_t sz = m_store->size();
      if( sz > 0 ) {
         return sz;
      }
      if( m_parentLink.isValid() ) {
         return m_parentLink->size();
      }
      return 0;
   }

toTransient()

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

overridevirtual

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

Implements SG::IAuxStore.

Definition at line 507 of file ShallowAuxContainer.cxx.

                                                                  {
     m_parentLink.toTransient( ctx );
     m_store->toTransient( ctx );
   }

Member Data Documentation

ATLAS_THREAD_SAFE [1/3]

bool m_auxidsValid xAOD::ShallowAuxContainer::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 213 of file ShallowAuxContainer.h.

ATLAS_THREAD_SAFE [2/3]

auxid_set_t m_decorids xAOD::ShallowAuxContainer::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 212 of file ShallowAuxContainer.h.

ATLAS_THREAD_SAFE [3/3]

auxid_set_t m_auxids xAOD::ShallowAuxContainer::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 211 of file ShallowAuxContainer.h.

m_locked

bool xAOD::ShallowAuxContainer::m_locked

private

Flag keeping track of whether this object is locked or not.

Definition at line 195 of file ShallowAuxContainer.h.

m_mutex

mutex_t xAOD::ShallowAuxContainer::m_mutex

mutableprivate

Definition at line 207 of file ShallowAuxContainer.h.

m_name

std::string xAOD::ShallowAuxContainer::m_name

private

Name of the container in memory. Set externally.

Definition at line 216 of file ShallowAuxContainer.h.

m_ownsStore

bool xAOD::ShallowAuxContainer::m_ownsStore

private

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

Definition at line 193 of file ShallowAuxContainer.h.

m_parentIO

const SG::IAuxStoreIO* xAOD::ShallowAuxContainer::m_parentIO

private

Optional pointer to the IO interface of the parent object.

Definition at line 200 of file ShallowAuxContainer.h.

m_parentLink

DataLink< SG::IConstAuxStore > xAOD::ShallowAuxContainer::m_parentLink

private

Link to the parent object.

Definition at line 198 of file ShallowAuxContainer.h.

m_selection

AuxSelection xAOD::ShallowAuxContainer::m_selection

private

Dynamic attributes selection implementation.

Definition at line 186 of file ShallowAuxContainer.h.

m_shallowIO

bool xAOD::ShallowAuxContainer::m_shallowIO

private

Flag for whether to do "shallow IO" or not.

Definition at line 202 of file ShallowAuxContainer.h.

m_store

SG::IAuxStore* xAOD::ShallowAuxContainer::m_store

private

Internal dynamic auxiliary store object.

Definition at line 189 of file ShallowAuxContainer.h.

m_storeIO

SG::IAuxStoreIO* xAOD::ShallowAuxContainer::m_storeIO

private

The IO interface to the internal auxiliary store.

Definition at line 191 of file ShallowAuxContainer.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:

• ShallowAuxContainer.h
• ShallowAuxContainer.cxx