xAOD::ShallowAuxContainer Class Reference

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

#include <ShallowAuxContainer.h>

Inheritance diagram for xAOD::ShallowAuxContainer:

Collaboration diagram for xAOD::ShallowAuxContainer:

Public Types
typedef SG::auxid_t	auxid_t
	The aux ID type definition. More...
typedef SG::auxid_set_t	auxid_set_t
	The aux ID set type definition. More...
enum	AuxStoreType { AST_ObjectStore = 0, AST_ContainerStore = 1 }
	Type of the auxiliary store. More...

Public Member Functions
	ShallowAuxContainer (bool standalone=false)
	Default constructor. More...
	ShallowAuxContainer (const ShallowAuxContainer &parent)
	Copy constructor. More...
	ShallowAuxContainer (const DataLink< SG::IConstAuxStore > &parent, bool standalone=false)
	Constructor with a parent object. More...
	~ShallowAuxContainer ()
	Destructor. More...
ShallowAuxContainer &	operator= (const ShallowAuxContainer &rhs)
	Assignment operator. More...
const DataLink< SG::IConstAuxStore > &	parent () const
	Get the parent store. More...
void	setParent (const DataLink< SG::IConstAuxStore > &link)
	Set the parent store. More...
bool	shallowIO () const
	Check whether only the overriden parameters will be written out or not. More...
void	setShallowIO (bool value)
	Set whether only the overriden parameters should be written out. More...
virtual const void *	getData (SG::auxid_t auxid) const=0
	Pick up the const version from the base class. More...
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. More...
virtual bool	setOption (auxid_t, const AuxDataOption &)
	Set an option for a given auxiliary variable. More...

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

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

Private Member Functions
void	remakeAuxIDs () const

Private Attributes
AuxSelection	m_selection
	Dynamic attributes selection implementation. More...
SG::IAuxStore *	m_store
	Internal dynamic auxiliary store object. More...
SG::IAuxStoreIO *	m_storeIO
	The IO interface to the internal auxiliary store. More...
bool	m_ownsStore
	Flag deciding if the object owns the dynamic store or not. More...
bool	m_locked
	Flag keeping track of whether this object is locked or not. More...
DataLink< SG::IConstAuxStore >	m_parentLink
	Link to the parent object. More...
const SG::IAuxStoreIO *	m_parentIO
	Optional pointer to the IO interface of the parent object. More...
bool	m_shallowIO
	Flag for whether to do "shallow IO" or not. More...
mutex_t	m_mutex
auxid_set_t m_auxids	ATLAS_THREAD_SAFE
bool m_auxidsValid	ATLAS_THREAD_SAFE
std::string	m_name
	Name of the container in memory. Set externally. More...

Functions implementing the SG::IAuxStoreHolder interface
virtual SG::IAuxStore *	getStore () override
	Get the currently used internal store object. More...
virtual const SG::IAuxStore *	getStore () const override
virtual void	setStore (SG::IAuxStore *store) override
	Set a different internal store object. More...
virtual AuxStoreType	getStoreType () const override
	Return the type of the store object. More...

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

auxid_t

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

The aux ID type definition.

Definition at line 58 of file ShallowAuxContainer.h.

guard_t

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

private

Definition at line 196 of file ShallowAuxContainer.h.

mutex_t

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

private

Mutex for multithread synchronization.

Definition at line 195 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 66 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 31 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 43 of file ShallowAuxContainer.cxx.

      : SG::IAuxStore(), SG::IAuxStoreIO(), SG::IAuxStoreHolder(),
        m_store( parent.m_store ), m_storeIO( parent.m_storeIO ),
        m_ownsStore( false ), m_locked( parent.m_locked ),
        m_parentLink( parent.m_parentLink ),
        m_parentIO( parent.m_parentIO ), m_shallowIO( parent.m_shallowIO ),
        m_auxids (),
        m_auxidsValid (false)
   {
      // Keep the source unmutable during copy
      guard_t guard( parent.m_mutex );
      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 62 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 77 of file ShallowAuxContainer.cxx.

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

Member Function Documentation

clearDecorations()

bool xAOD::ShallowAuxContainer::clearDecorations ( )

overridevirtual

Clear all decorations.

Implements SG::IConstAuxStore.

Definition at line 354 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.

Implements SG::IConstAuxStore.

Definition at line 218 of file ShallowAuxContainer.cxx.

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

getData() [1/3]

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

overridevirtual

Get a pointer to a given array.

Implements SG::IConstAuxStore.

Definition at line 187 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 void* result = m_store->getData( auxid );
      if( result ) {
         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->getData( auxid );
         if( result && ( nids != m_parentLink->getAuxIDs().size() ) ) {
            remakeAuxIDs();
         }
         return result;
      }
 
      // Apparently the variable wasn't found:
      return nullptr;
   }

getData() [2/3]

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 373 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 );
 
      remakeAuxIDs();
 
      // 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;
      }
 
      // 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 ) {
         std::ostringstream message;
         message << "Couldn't find the type of auxiliary ID " << auxid;
         throw std::runtime_error( message.str() );
      }
 
      // And the allocator type for this variable.
      const std::type_info* allocType = reg.getAllocType( auxid );
      if( allocType == nullptr ) {
         std::ostringstream message;
         message << "Couldn't find the allocator type of auxiliary ID " << auxid;
         throw std::runtime_error( message.str() );
      }
 
      // First let's get the vector factory of this variable:
      const SG::IAuxTypeVectorFactory* factory =
        SG::AuxTypeRegistry::instance().getFactory( *type, *allocType );
      if( factory == nullptr ) {
         std::ostringstream message;
         message << "Couldn't find a factory for type " << type->name();
         throw std::runtime_error( message.str() );
      }
 
      // 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;
   }

getData() [3/3]

virtual const void* SG::IConstAuxStore::getData

inherited

Pick up the const version from the base class.

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.

Implements SG::IConstAuxStore.

Definition at line 239 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 ) {
         std::ostringstream message;
         message << "Couldn't find the type of auxiliary ID " << auxid;
         throw std::runtime_error( message.str() );
      }
 
      // And the allocator type for this variable.
      const std::type_info* allocType = reg.getAllocType( auxid );
      if( allocType == nullptr ) {
         std::ostringstream message;
         message << "Couldn't find the allocator type of auxiliary ID " << auxid;
         throw std::runtime_error( message.str() );
      }
 
      // Get the vector factory of this variable.
      const SG::IAuxTypeVectorFactory* factory =
         SG::AuxTypeRegistry::instance().getFactory( *type, *allocType );
      if( factory == nullptr ) {
         std::ostringstream message;
         message << "Couldn't find a factory for type " << type->name();
         throw std::runtime_error( message.str() );
      }
 
      // 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;
   }

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 543 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 490 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::cerr << "ERROR xAOD::ShallowAuxContainer::getIOData Unknown "
                << "variable ("
                << SG::AuxTypeRegistry::instance().getName( auxid )
                << ") requested" << std::endl;
      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 516 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::cerr << "ERROR xAOD::ShallowAuxContainer::getIOType Unknown "
                << "variable ("
                << SG::AuxTypeRegistry::instance().getName( auxid )
                << ") requested" << std::endl;
      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 558 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 154 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 149 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 94 of file ShallowAuxContainer.h.

{ return AST_ContainerStore; }

getWritableAuxIDs()

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

overridevirtual

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 442 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]

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 473 of file ShallowAuxContainer.cxx.

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

insertMove() [2/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.

isDecoration()

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

overridevirtual

Test if a variable is a decoration.

Implements SG::IConstAuxStore.

Definition at line 227 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);
   }

lock()

void xAOD::ShallowAuxContainer::lock ( )

overridevirtual

Lock the container.

Implements ILockable.

Definition at line 325 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.

Implements SG::IConstAuxStore.

Definition at line 334 of file ShallowAuxContainer.cxx.

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

name()

const char * xAOD::ShallowAuxContainer::name

(

)

const

Get the name of the container instance.

Definition at line 575 of file ShallowAuxContainer.cxx.

                                               {
 
      return m_name.c_str();
   }

operator=()

ShallowAuxContainer & xAOD::ShallowAuxContainer::operator=

(

const ShallowAuxContainer &

rhs

)

Assignment operator.

Definition at line 85 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 117 of file ShallowAuxContainer.cxx.

                                                                         {
 
      return m_parentLink;
   }

remakeAuxIDs()

void xAOD::ShallowAuxContainer::remakeAuxIDs ( ) const

private

Definition at line 586 of file ShallowAuxContainer.cxx.

                                                {
     auxid_set_t ids = m_store->getAuxIDs();
     if( m_parentLink.isValid() ) {
       ids.insert (m_parentLink->getAuxIDs());
     }
     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 459 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 449 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 580 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, xAOD::AuxInfoBase, and SG::AuxStoreInternal.

Definition at line 176 of file IAuxStore.h.

  { return false; }

setParent()

void xAOD::ShallowAuxContainer::setParent

(

const DataLink< SG::IConstAuxStore > &

link

)

Set the parent store.

Definition at line 122 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 137 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 159 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 132 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 466 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.

Implements SG::IConstAuxStore.

Definition at line 340 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;
   }

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

auxid_set_t m_auxids xAOD::ShallowAuxContainer::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 201 of file ShallowAuxContainer.h.

ATLAS_THREAD_SAFE [2/2]

bool m_auxidsValid xAOD::ShallowAuxContainer::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 202 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 185 of file ShallowAuxContainer.h.

m_mutex

mutex_t xAOD::ShallowAuxContainer::m_mutex

mutableprivate

Definition at line 197 of file ShallowAuxContainer.h.

m_name

std::string xAOD::ShallowAuxContainer::m_name

private

Name of the container in memory. Set externally.

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

m_parentLink

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

private

Link to the parent object.

Definition at line 188 of file ShallowAuxContainer.h.

m_selection

AuxSelection xAOD::ShallowAuxContainer::m_selection

private

Dynamic attributes selection implementation.

Definition at line 176 of file ShallowAuxContainer.h.

m_shallowIO

bool xAOD::ShallowAuxContainer::m_shallowIO

private

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

Definition at line 192 of file ShallowAuxContainer.h.

m_store

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

private

Internal dynamic auxiliary store object.

Definition at line 179 of file ShallowAuxContainer.h.

m_storeIO

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

private

The IO interface to the internal auxiliary store.

Definition at line 181 of file ShallowAuxContainer.h.

supportsThinning

constexpr 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 189 of file IAuxStore.h.

---

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

• ShallowAuxContainer.h
• ShallowAuxContainer.cxx