xAOD::ShallowAuxInfo Class Reference

Shallow copy for the auxiliary store of standalone objects. More...

#include <ShallowAuxInfo.h>

Inheritance diagram for xAOD::ShallowAuxInfo:

Collaboration diagram for xAOD::ShallowAuxInfo:

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
	ShallowAuxInfo ()
	Default constructor.
	ShallowAuxInfo (const DataLink< SG::IConstAuxStore > &parent)
	Constructor with a parent object.
virtual AuxStoreType	getStoreType () const
	Return the type of the store object.
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.
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 = false
	Flag that we should not use the xAOD aux store pool converter for this type.

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

Shallow copy for the auxiliary store of standalone objects.

The design of this is exactly the same as for the SG::AuxStoreInternal - SG::AuxStoreStandalone pair. All the code is in xAOD::ShallowAuxContainer, this class is just a convenience shorthand for calling xAOD::ShallowAuxContainer(true) in the code.

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

671678

Date

2015-06-02 14:28:46 +0200 (Tue, 02 Jun 2015)

Definition at line 33 of file ShallowAuxInfo.h.

Member Typedef Documentation

auxid_set_t

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

inherited

The aux ID set type definition.

Definition at line 56 of file ShallowAuxContainer.h.

auxid_t

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

inherited

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

privateinherited

Definition at line 206 of file ShallowAuxContainer.h.

mutex_t

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

privateinherited

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

ShallowAuxInfo() [1/2]

xAOD::ShallowAuxInfo::ShallowAuxInfo

(

)

Default constructor.

Definition at line 12 of file ShallowAuxInfo.cxx.

      : ShallowAuxContainer( true ) {
 
   }

ShallowAuxInfo() [2/2]

xAOD::ShallowAuxInfo::ShallowAuxInfo

(

const DataLink< SG::IConstAuxStore > &

parent

)

Constructor with a parent object.

Definition at line 17 of file ShallowAuxInfo.cxx.

      : ShallowAuxContainer( parent, true ) {
 
   }

Member Function Documentation

clearDecorations()

bool xAOD::ShallowAuxContainer::clearDecorations ( )

overridevirtualinherited

Clear all decorations.

Definition at line 390 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

overridevirtualinherited

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

Definition at line 232 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

overridevirtualinherited

Get the set of variables that we should deep copy.

Definition at line 251 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

overridevirtualinherited

Get a pointer to a given array.

Definition at line 192 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 )

overridevirtualinherited

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

Implements SG::IAuxStore.

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

getDecoration()

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

overridevirtualinherited

Return the data vector for one aux data decoration item.

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

getDecorIDs()

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

overridevirtualinherited

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

Definition at line 242 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

overridevirtualinherited

Get the types(names) of variables created dynamically.

Implements SG::IAuxStoreIO.

Definition at line 585 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

overridevirtualinherited

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

Implements SG::IAuxStoreIO.

Definition at line 532 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

overridevirtualinherited

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

Implements SG::IAuxStoreIO.

Definition at line 558 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

overridevirtualinherited

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

Reimplemented from SG::IAuxStoreIO.

Definition at line 600 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

overridevirtualinherited

Implements SG::IAuxStoreHolder.

Definition at line 159 of file ShallowAuxContainer.cxx.

   {
      return m_store;
   }

getStore() [2/2]

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

overridevirtualinherited

Get the currently used internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 154 of file ShallowAuxContainer.cxx.

   {
      return m_store;
   }

getStoreType()

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

inlinevirtual

Return the type of the store object.

Reimplemented from xAOD::ShallowAuxContainer.

Definition at line 47 of file ShallowAuxInfo.h.

{ return AST_ObjectStore; }

getVector()

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

finaloverridevirtualinherited

Return vector interface for one aux data item.

Definition at line 201 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

overridevirtualinherited

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 478 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 )

overridevirtualinherited

Insert contents of another store via move.

Definition at line 509 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

overridevirtualinherited

Test if a variable is a decoration.

Definition at line 262 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 ( )

overridevirtualinherited

Lock the container.

Definition at line 360 of file ShallowAuxContainer.cxx.

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

lockDecoration()

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

overridevirtualinherited

Lock a decoration.

Definition at line 369 of file ShallowAuxContainer.cxx.

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

name()

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

inherited

Get the name of the container instance.

Definition at line 617 of file ShallowAuxContainer.cxx.

                                               {
 
      return m_name.c_str();
   }

parent()

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

inherited

Get the parent store.

Definition at line 122 of file ShallowAuxContainer.cxx.

                                                                         {
 
      return m_parentLink;
   }

remakeAuxIDs()

void xAOD::ShallowAuxContainer::remakeAuxIDs ( ) const

privateinherited

Definition at line 628 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());
     }
 
     m_decorids = std::move(decors);
     std::atomic_thread_fence( std::memory_order_seq_cst );
     m_auxids = std::move(ids);
 
     m_auxidsValid = true;
   }

reserve()

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

overridevirtualinherited

Reserve a given size for the arrays.

Implements SG::IAuxStore.

Definition at line 495 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 )

overridevirtualinherited

Resize the arrays to a given size.

Implements SG::IAuxStore.

Definition at line 485 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 )

inherited

Set the name of the container instance.

Definition at line 622 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 )

inherited

Set the parent store.

Definition at line 127 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 )

inherited

Set whether only the overriden parameters should be written out.

Definition at line 142 of file ShallowAuxContainer.cxx.

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

setStore()

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

overridevirtualinherited

Set a different internal store object.

Implements SG::IAuxStoreHolder.

Definition at line 164 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

inherited

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

Definition at line 137 of file ShallowAuxContainer.cxx.

                                             {
 
      return m_shallowIO;
   }

shift()

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

overridevirtualinherited

Shift the contents of the stored arrays.

Implements SG::IAuxStore.

Definition at line 502 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

overridevirtualinherited

Get the size of the container.

Definition at line 376 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 )

overridevirtualinherited

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

Implements SG::IAuxStore.

Definition at line 518 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

mutableprivateinherited

Definition at line 213 of file ShallowAuxContainer.h.

ATLAS_THREAD_SAFE [2/3]

auxid_set_t m_decorids xAOD::ShallowAuxContainer::ATLAS_THREAD_SAFE

mutableprivateinherited

Definition at line 212 of file ShallowAuxContainer.h.

ATLAS_THREAD_SAFE [3/3]

auxid_set_t m_auxids xAOD::ShallowAuxContainer::ATLAS_THREAD_SAFE

mutableprivateinherited

Definition at line 211 of file ShallowAuxContainer.h.

m_locked

bool xAOD::ShallowAuxContainer::m_locked

privateinherited

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

mutableprivateinherited

Definition at line 207 of file ShallowAuxContainer.h.

m_name

std::string xAOD::ShallowAuxContainer::m_name

privateinherited

Name of the container in memory. Set externally.

Definition at line 216 of file ShallowAuxContainer.h.

m_ownsStore

bool xAOD::ShallowAuxContainer::m_ownsStore

privateinherited

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

privateinherited

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

privateinherited

Link to the parent object.

Definition at line 198 of file ShallowAuxContainer.h.

m_selection

AuxSelection xAOD::ShallowAuxContainer::m_selection

privateinherited

Dynamic attributes selection implementation.

Definition at line 186 of file ShallowAuxContainer.h.

m_shallowIO

bool xAOD::ShallowAuxContainer::m_shallowIO

privateinherited

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

privateinherited

Internal dynamic auxiliary store object.

Definition at line 189 of file ShallowAuxContainer.h.

m_storeIO

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

privateinherited

The IO interface to the internal auxiliary store.

Definition at line 191 of file ShallowAuxContainer.h.

supportsThinning

bool xAOD::ShallowAuxInfo::supportsThinning = false

staticconstexpr

Flag that we should not use the xAOD aux store pool converter for this type.

Definition at line 39 of file ShallowAuxInfo.h.

---

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

• ShallowAuxInfo.h
• ShallowAuxInfo.cxx