xAOD::details::AuxStoreBase Class Reference

Common base class for the auxiliary store implementations. More...

#include <AuxStoreBase.h>

Inheritance diagram for xAOD::details::AuxStoreBase:

Collaboration diagram for xAOD::details::AuxStoreBase:

Classes
struct	Members
	Struct collecting all member variables of this base class. More...

Public Types
enum class	EStructMode { kUndefinedStore = 0 , kContainerStore = 1 , kObjectStore = 2 }
	"Structural" modes of the object More...

Public Member Functions
	AuxStoreBase (bool topStore=true, EStructMode mode=EStructMode::kUndefinedStore)
	Constructor.
virtual	~AuxStoreBase ()
	Destructor.
EStructMode	structMode () const
	Get what structure mode the object was constructed with.
void	setStructMode (EStructMode mode)
	Set the structure mode of the object to a new value.
const std::string &	prefix () const
	Get the currently configured object name prefix.
virtual void	setPrefix (std::string_view prefix)=0
	Set the object name prefix.
bool	isTopStore () const
	Check if the object is a "top store", or not.
void	setTopStore (bool value=true)
	Set whether the object should behave as a "top store" or not.
virtual void *	getData (auxid_t auxid, size_t size, size_t capacity)=0
	Return the data vector for one aux data item.
virtual bool	resize (size_t sz)=0
	Change the size of all aux data vectors.
virtual void	reserve (size_t sz)=0
	Change the capacity of all aux data vectors.
virtual void	shift (size_t pos, ptrdiff_t offs)=0
	Shift the elements of the container.
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.
Functions implementing the @c SG::IConstAuxStore interface
virtual const void *	getData (SG::auxid_t auxid) const override
	Get a pointer to a given array.
virtual const SG::IAuxTypeVector *	getVector (SG::auxid_t auxid) const override
	Return vector interface for one aux data item.
virtual const SG::auxid_set_t &	getAuxIDs () const override
	Get the types(names) of variables handled by this container.
virtual const SG::auxid_set_t &	getDecorIDs () const override
	Get the types(names) of decorations handled by this container.
virtual void *	getDecoration (SG::auxid_t auxid, std::size_t size, std::size_t capacity) override
	Get a pointer to a given array, creating the array if necessary.
virtual SG::auxid_set_t	getCopyIDs (bool warnUnlocked=false) const override
	Get the set of variables that we should deep copy.
virtual bool	isDecoration (SG::auxid_t auxid) const override
	Test if a variable is a decoration.
virtual void	lock () override
	Lock the object, and don't let decorations be added.
virtual bool	clearDecorations () override
	Remove the decorations added so far.
virtual void	lockDecoration (SG::auxid_t auxid) override
	Lock a decoration.
virtual std::size_t	size () const override
	Return the number of elements in the store.
virtual const SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) const override
	Return (const) interface for a linked variable.
virtual SG::IAuxTypeVector *	linkedVector (SG::auxid_t auxid) override
	Return (non-const) interface for a linked variable.
virtual void	toTransient (const EventContext &ctx) override
	Call toTransient on contained variables.
Functions implementing the @c SG::IAuxStore interface
virtual void *	getData (SG::auxid_t auxid, std::size_t size, std::size_t capacity) override
	Get a pointer to a given array, creating the array if necessary.
virtual const SG::auxid_set_t &	getWritableAuxIDs () const override
	Return a set of writable data identifiers.
virtual bool	resize (std::size_t size) override
	Resize the arrays to a given size.
virtual void	reserve (std::size_t size) override
	Reserve a given size for the arrays.
virtual void	shift (std::size_t pos, std::ptrdiff_t offs) override
	Shift the contents of the stored arrays.
virtual bool	insertMove (std::size_t pos, SG::IAuxStore &other, const SG::auxid_set_t &ignore) override
	Insert contents of another store via move.
Functions implementing the SG::IAuxStoreIO interface
virtual const void *	getIOData (SG::auxid_t auxid) const override
	Get a pointer to the data being stored for one aux data item.
virtual const std::type_info *	getIOType (SG::auxid_t auxid) const override
	Return the type of the data to be stored for one aux data item.
virtual const SG::auxid_set_t &	getDynamicAuxIDs () const override
	Get the types(names) of variables created dynamically.
virtual void	selectAux (const std::set< std::string > &attributes)
	Select dynamic auxiliary attributes for writing.
virtual SG::auxid_set_t	getSelectedAuxIDs () const override
	Get the IDs of the selected aux variables.

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

Protected Types
using	mutex_t = AthContainers_detail::mutex
	Mutex type for multithread synchronization.
using	guard_t = AthContainers_detail::lock_guard<mutex_t>
	Guard type for multithreaded synchronisation.

Protected Member Functions
bool	isAuxIDSelected (SG::auxid_t auxid) const
	Check if an auxiliary variable is selected for ouput writing.
Functions needed from the derived classes
virtual void	reset ()=0
	Reset all (transient) information in the object.
virtual bool	hasEntryFor (SG::auxid_t auxid) const =0
	Check if a given variable is available from the input.
virtual StatusCode	getEntryFor (SG::auxid_t auxid)=0
	Load a single variable from the input.
virtual bool	hasOutput () const =0
	Check if an output is being written by the object.
virtual StatusCode	setupInputData (SG::auxid_t auxid)=0
	Connect a variable to the input.
virtual StatusCode	setupOutputData (SG::auxid_t auxid)=0
	Connect a variable to the output.
virtual const void *	getInputObject (SG::auxid_t auxid) const =0
	Get a pointer to an input object, as it is in memory, for getIOData().
virtual const std::type_info *	getInputType (SG::auxid_t auxid) const =0
	Get the type of an input object, for getIOType().

Protected Attributes
Members	m_data
	Member variables of the base class.

Private Attributes
AuxSelection	m_selection
	Object helping to select which auxiliary variables to write.
bool	m_locked = false
	Is this container locked?
mutex_t	m_mutex1
	Mutex objects used for multithreaded synchronisation.
mutex_t	m_mutex2

Detailed Description

Common base class for the auxiliary store implementations.

This class provides the common functionality for the auxiliary store implementations in xAODRootAccess. Reducing the amount of code duplication in the different classes.

Definition at line 26 of file AuxStoreBase.h.

Member Typedef Documentation

guard_t

using xAOD::details::AuxStoreBase::guard_t = AthContainers_detail::lock_guard<mutex_t>

protected

Guard type for multithreaded synchronisation.

Definition at line 212 of file AuxStoreBase.h.

mutex_t

using xAOD::details::AuxStoreBase::mutex_t = AthContainers_detail::mutex

protected

Mutex type for multithread synchronization.

Definition at line 210 of file AuxStoreBase.h.

Member Enumeration Documentation

EStructMode

enum class xAOD::details::AuxStoreBase::EStructMode

strong

"Structural" modes of the object

Enumerator
kUndefinedStore	The structure mode is not defined.
kContainerStore	The object describes an entire container.
kObjectStore	The object describes a single object.

Definition at line 30 of file AuxStoreBase.h.

                         {
    kUndefinedStore = 0,  
    kContainerStore = 1,  
    kObjectStore = 2      
  };

Constructor & Destructor Documentation

AuxStoreBase()

xAOD::details::AuxStoreBase::AuxStoreBase	(	bool	topStore = true,
		EStructMode	mode = EStructMode::kUndefinedStore )

Constructor.

Definition at line 24 of file AuxStoreBase.cxx.

    : m_data{mode, topStore} {}

~AuxStoreBase()

xAOD::details::AuxStoreBase::~AuxStoreBase ( )

virtualdefault

Destructor.

Member Function Documentation

clearDecorations()

bool xAOD::details::AuxStoreBase::clearDecorations ( )

overridevirtual

Remove the decorations added so far.

Only works for transient decorations.

Definition at line 222 of file AuxStoreBase.cxx.

                                    {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // Clear the transient decorations:
  bool anycleared = false;
  if (m_data.m_transientStore) {
    SG::auxid_set_t old_id_set = m_data.m_transientStore->getAuxIDs();
 
    // Clear the decorations from the transient store:
    anycleared = m_data.m_transientStore->clearDecorations();
 
    // Now remove ids that were cleared.
    if (anycleared) {
      old_id_set -= m_data.m_transientStore->getAuxIDs();
      // old_id_set is now the set of ids that were cleared.
      m_data.m_auxIDs -= old_id_set;
      m_data.m_decorIDs.clear();
    }
  }
 
  // The decorations which are going into the output file, are here to stay.
  // Removing their IDs from the internal set would just cause more problems
  // in my mind than just leaving them be.
 
  return anycleared;
}

getAuxIDs()

const SG::auxid_set_t & xAOD::details::AuxStoreBase::getAuxIDs ( ) const

overridevirtual

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

Definition at line 106 of file AuxStoreBase.cxx.

                                                   {
 
  return m_data.m_auxIDs;
}

getCopyIDs()

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

overridevirtual

Get the set of variables that we should deep copy.

Definition at line 193 of file AuxStoreBase.cxx.

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

getData() [1/3]

virtual void * SG::IAuxStore::getData ( auxid_t auxid, size_t size, size_t capacity )

pure virtualinherited

Return the data vector for one aux data item.

Parameters

auxid	The identifier of the desired aux data item.
size	The current size of the container (in case the data item does not already exist).
capacity	The current capacity of the container (in case the data item does not already exist).

Each aux data item is stored as a vector, with one entry per entry in the owning container. This returns a pointer to the start of the vector.

If the data item does not exist, it should be created and initialized to default values. size and capacity give the size for the new aux data item vector.

If the container is locked, throw an exception.

Implemented in xAOD::AuxContainerBase, xAOD::AuxInfoBase, xAOD::ByteStreamAuxContainer_v1, and xAOD::ShallowAuxContainer.

getData() [2/3]

const void * xAOD::details::AuxStoreBase::getData ( SG::auxid_t auxid ) const

overridevirtual

Get a pointer to a given array.

Definition at line 56 of file AuxStoreBase.cxx.

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

getData() [3/3]

void * xAOD::details::AuxStoreBase::getData ( SG::auxid_t auxid, std::size_t size, std::size_t capacity )

overridevirtual

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

Definition at line 328 of file AuxStoreBase.cxx.

                                                {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex2);
 
  // Remember the size:
  m_data.m_size = size;
 
  // Check if we want to write this variable to the output:
  if (!(isAuxIDSelected(auxid) && hasOutput())) {
    // Create the store only when necessary:
    if (!m_data.m_transientStore) {
      m_data.m_transientStore = std::make_unique<SG::AuxStoreInternal>(
          m_data.m_structMode == EStructMode::kObjectStore);
      if (m_locked) {
        m_data.m_transientStore->lock();
      }
    }
    // Let the transient store create the variable:
    std::size_t nids = m_data.m_transientStore->getAuxIDs().size();
    void* result = m_data.m_transientStore->getData(auxid, size, capacity);
    if (result && (nids != m_data.m_transientStore->getAuxIDs().size())) {
      m_data.m_auxIDs.insert(auxid);
    }
    // Return the address in the transient memory:
    return result;
  }
 
  // If the variable exists already, and this is a locked store, then
  // we are in trouble.
  if (m_locked && (auxid < m_data.m_vecs.size()) && m_data.m_vecs[auxid]) {
    if (!((auxid < m_data.m_isDecoration.size()) &&
          m_data.m_isDecoration[auxid])) {
      throw SG::ExcStoreLocked(auxid);
    }
  }
 
  // Connect this auxiliary variable just to the output:
  if (setupOutputData(auxid).isFailure()) {
    ::Error("xAOD::AuxStoreBase::getData",
            XAOD_MESSAGE("Failed to set up variable %s"),
            SG::AuxTypeRegistry::instance().getName(auxid).c_str());
    return nullptr;
  }
 
  // Check whether things make sense:
  if ((m_data.m_structMode == EStructMode::kObjectStore) && (size != 1)) {
    ::Error("xAOD::AuxStoreBase::getData",
            XAOD_MESSAGE("Branch creation requested with:"));
    ::Error("xAOD::AuxStoreBase::getData", XAOD_MESSAGE("  name = %s"),
            SG::AuxTypeRegistry::instance().getName(auxid).c_str());
    ::Error("xAOD::AuxStoreBase::getData", XAOD_MESSAGE("  size = %i"),
            static_cast<int>(size));
    ::Error("xAOD::AuxStoreBase::getData",
            XAOD_MESSAGE("  m_structMode = EStructMode::kObjectStore"));
    return nullptr;
  }
 
  // Make sure the variable is of the right size:
  m_data.m_vecs[auxid]->reserve(capacity);
  m_data.m_vecs[auxid]->resize(size);
 
  // Return the object:
  return m_data.m_vecs[auxid]->toPtr();
}

getDecoration()

void * xAOD::details::AuxStoreBase::getDecoration ( SG::auxid_t auxid, std::size_t size, std::size_t capacity )

overridevirtual

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

Definition at line 116 of file AuxStoreBase.cxx.

                                                      {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // Remember the requested size:
  m_data.m_size = size;
 
  // If this is a locked object, deal with it correctly:
  if (m_locked) {
    // If the variable exists already and it's a decoration, then let's
    // give it back.
    if ((auxid < m_data.m_vecs.size()) && m_data.m_vecs[auxid] &&
        (auxid < m_data.m_isDecoration.size() &&
         m_data.m_isDecoration[auxid])) {
      // Things look okay...
      m_data.m_vecs[auxid]->reserve(capacity);
      m_data.m_vecs[auxid]->resize(size);
      return m_data.m_vecs[auxid]->toPtr();
    }
    // If it's in the transient store already, return it from there.
    // Since in a locked store *everything* is a decoration in the
    // transient store.
    if (m_data.m_transientStore &&
        m_data.m_transientStore->getAuxIDs().test(auxid)) {
      return m_data.m_transientStore->getDecoration(auxid, size, capacity);
    }
    // If we know this auxiliary ID, but it was not found as a decoration
    // by the previous checks, then we're in trouble.
    if (m_data.m_auxIDs.test(auxid)) {
      throw SG::ExcStoreLocked(auxid);
    }
  }
 
  // Check if we want to write this variable to the output:
  if (!(isAuxIDSelected(auxid) && hasOutput())) {
 
    // Create the store only when necessary:
    if (!m_data.m_transientStore) {
      m_data.m_transientStore = std::make_unique<SG::AuxStoreInternal>(
          m_data.m_structMode == EStructMode::kObjectStore);
      if (m_locked) {
        m_data.m_transientStore->lock();
      }
    }
    // Let the transient store create the decoration:
    const std::size_t nids = m_data.m_transientStore->getAuxIDs().size();
    void* result =
        m_data.m_transientStore->getDecoration(auxid, size, capacity);
    if (result && (nids != m_data.m_transientStore->getAuxIDs().size())) {
      if (m_data.m_transientStore->isDecoration(auxid)) {
        m_data.m_decorIDs.insert(auxid);
      }
      std::atomic_thread_fence( std::memory_order_seq_cst );
      m_data.m_auxIDs.insert(auxid);
    }
    // Return the memory address from the transient store:
    return result;
  }
 
  // Doesn't exist yet. So let's make it:
  if (m_locked) {
    // If the container is locked, remember that this is a decoration:
    if (m_data.m_isDecoration.size() <= auxid) {
      m_data.m_isDecoration.resize(auxid + 1);
    }
    m_data.m_isDecoration[auxid] = true;
    m_data.m_decorIDs.insert(auxid);
    std::atomic_thread_fence( std::memory_order_seq_cst );
  }
  void* result = getData(auxid, size, capacity);
 
  // Return the pointer made by getData(...):
  return result;
}

getDecorIDs()

const SG::auxid_set_t & xAOD::details::AuxStoreBase::getDecorIDs ( ) const

overridevirtual

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

Definition at line 111 of file AuxStoreBase.cxx.

                                                     {
 
  return m_data.m_decorIDs;
}

getDynamicAuxIDs()

const SG::auxid_set_t & xAOD::details::AuxStoreBase::getDynamicAuxIDs ( ) const

overridevirtual

Get the types(names) of variables created dynamically.

Implements SG::IAuxStoreIO.

Definition at line 637 of file AuxStoreBase.cxx.

                                                          {
 
  // All the auxiliary decorations handled by this object are considered
  // dynamic:
  return getAuxIDs();
}

getEntryFor()

virtual StatusCode xAOD::details::AuxStoreBase::getEntryFor ( SG::auxid_t auxid )

protectedpure virtual

Load a single variable from the input.

Implemented in xAOD::RAuxStore, and xAOD::TAuxStore.

getInputObject()

virtual const void * xAOD::details::AuxStoreBase::getInputObject ( SG::auxid_t auxid ) const

protectedpure virtual

Get a pointer to an input object, as it is in memory, for getIOData().

Implemented in xAOD::RAuxStore, and xAOD::TAuxStore.

getInputType()

virtual const std::type_info * xAOD::details::AuxStoreBase::getInputType ( SG::auxid_t auxid ) const

protectedpure virtual

Get the type of an input object, for getIOType().

Implemented in xAOD::RAuxStore, and xAOD::TAuxStore.

getIOData()

const void * xAOD::details::AuxStoreBase::getIOData ( SG::auxid_t auxid ) const

overridevirtual

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

Implements SG::IAuxStoreIO.

Definition at line 539 of file AuxStoreBase.cxx.

                                                         {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  auto this_nc ATLAS_THREAD_SAFE =
      const_cast<AuxStoreBase*>(this);  // locked above
 
  // If the variable is coming from the input, and is connected to already.
  if (hasEntryFor(auxid)) {
    if (!this_nc->getEntryFor(auxid).isSuccess()) {
      ::Error("xAOD::AuxStoreBase::getIOData",
              XAOD_MESSAGE("Couldn't read in variable %s"),
              SG::AuxTypeRegistry::instance().getName(auxid).c_str());
      return nullptr;
    }
    return getInputObject(auxid);
  }
 
  // Check if it's in the transient store:
  if (m_data.m_transientStore &&
      m_data.m_transientStore->getAuxIDs().test(auxid)) {
    return m_data.m_transientStore->getIOData(auxid);
  }
 
  // If not, try connecting to it now:
  if (!this_nc->setupInputData(auxid).isSuccess()) {
    // This is not actually an error condition anymore. We can end up here
    // when we decorate constant objects coming from the input file, but
    // on one event we can't set any decorations. For instance when the
    // input container is empty. In that case the object will still list
    // the auxiliary ID belonging to that decoration as being available,
    // but it really isn't.
    //
    // Later on it might be needed to tweak the logic of all of this, but
    // for now just silently returning 0 seems to do the right thing.
    return nullptr;
  }
 
  // Now we should know this variable:
  if (!hasEntryFor(auxid)) {
    ::Fatal("xAOD::AuxStoreBase::getIOData",
            XAOD_MESSAGE("Internal logic error detected"));
    return nullptr;
  }
 
  // Make sure that the right payload is in memory:
  if (!this_nc->getEntryFor(auxid).isSuccess()) {
    ::Error("xAOD::AuxStoreBase::getIOData",
            XAOD_MESSAGE("Couldn't read in variable %s"),
            SG::AuxTypeRegistry::instance().getName(auxid).c_str());
    return nullptr;
  }
 
  // Return the pointer.
  return getInputObject(auxid);
}

getIOType()

const std::type_info * xAOD::details::AuxStoreBase::getIOType ( SG::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 598 of file AuxStoreBase.cxx.

                                                                 {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // If the variable is connected to already:
  if (hasEntryFor(auxid)) {
    return getInputType(auxid);
  }
 
  // Check if it's in the transient store:
  if (m_data.m_transientStore &&
      m_data.m_transientStore->getAuxIDs().test(auxid)) {
    return m_data.m_transientStore->getIOType(auxid);
  }
 
  // If not, try connecting to it now:
  auto this_nc ATLAS_THREAD_SAFE =
      const_cast<AuxStoreBase*>(this);  // locked above
  if (!this_nc->setupInputData(auxid).isSuccess()) {
    ::Error("xAOD::AuxStoreBase::getIOType",
            XAOD_MESSAGE("Couldn't connect to auxiliary variable "
                         "%i %s"),
            static_cast<int>(auxid),
            SG::AuxTypeRegistry::instance().getName(auxid).c_str());
    return nullptr;
  }
 
  // Now we should know this variable:
  if (!hasEntryFor(auxid)) {
    ::Fatal("xAOD::AuxStoreBase::getIOType",
            XAOD_MESSAGE("Internal logic error detected"));
    return nullptr;
  }
 
  // Return the type info:
  return getInputType(auxid);
}

getSelectedAuxIDs()

SG::auxid_set_t xAOD::details::AuxStoreBase::getSelectedAuxIDs ( ) const

overridevirtual

Get the IDs of the selected aux variables.

Reimplemented from SG::IAuxStoreIO.

Definition at line 652 of file AuxStoreBase.cxx.

                                                    {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
  // Leave the calculation up to the internal object:
  return m_selection.getSelectedAuxIDs(m_data.m_auxIDs);
}

getVector()

const SG::IAuxTypeVector * xAOD::details::AuxStoreBase::getVector ( SG::auxid_t auxid ) const

overridevirtual

Return vector interface for one aux data item.

Definition at line 65 of file AuxStoreBase.cxx.

                                                                     {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // Check if the transient store already handles this variable:
  if (m_data.m_transientStore &&
      (m_data.m_transientStore->getAuxIDs().test(auxid))) {
    return m_data.m_transientStore->getVector(auxid);
  }
 
  // Access the object through a non-const pointer. This is "safe" because
  // of the mutex lock above.
  auto this_nc ATLAS_THREAD_SAFE = const_cast<AuxStoreBase*>(this);
 
  // Connect this auxiliary variable both to the input and output
  // if needed:
  if ((auxid >= m_data.m_vecs.size()) || (!m_data.m_vecs[auxid])) {
    if ((!this_nc->setupInputData(auxid).isSuccess()) ||
        (!this_nc->setupOutputData(auxid).isSuccess())) {
      return nullptr;
    }
  }
 
  // Make sure the variable is up to date:
  if (this_nc->getEntryFor(auxid).isSuccess() == false) {
    ::Error("xAOD::AuxStoreBase::getVector",
            XAOD_MESSAGE("Couldn't read in variable %s"),
            SG::AuxTypeRegistry::instance().getName(auxid).c_str());
    return nullptr;
  }
 
  // Let the AuxTypeVector object know that the std::vector that it manages
  // has changed.   (This updates the cached span.)
  SG::IAuxTypeVector* vec = m_data.m_vecs[auxid].get();
  vec->resize (vec->size());
 
  // Return the pointer to the object:
  return vec;
}

getWritableAuxIDs()

const SG::auxid_set_t & xAOD::details::AuxStoreBase::getWritableAuxIDs ( ) const

overridevirtual

Return a set of writable data identifiers.

Implements SG::IAuxStore.

Definition at line 395 of file AuxStoreBase.cxx.

                                                           {
 
  return getAuxIDs();
}

hasEntryFor()

virtual bool xAOD::details::AuxStoreBase::hasEntryFor ( SG::auxid_t auxid ) const

protectedpure virtual

Check if a given variable is available from the input.

Implemented in xAOD::RAuxStore, and xAOD::TAuxStore.

hasOutput()

virtual bool xAOD::details::AuxStoreBase::hasOutput ( ) const

protectedpure virtual

Check if an output is being written by the object.

Implemented in xAOD::RAuxStore, and xAOD::TAuxStore.

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

overridevirtual

Insert contents of another store via move.

Definition at line 489 of file AuxStoreBase.cxx.

                                                              {
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // A sanity check:
  if (m_data.m_structMode == EStructMode::kObjectStore) {
    ::Error("xAOD::AuxStoreBase::insertMove",
            XAOD_MESSAGE("Should not have been called for single-object "
                         "store"));
    return false;
  }
 
  bool nomove = true;
  std::size_t other_size = other.size();
 
  SG::auxid_set_t ignore = ignore_in;
 
  for (SG::auxid_t id : m_data.m_auxIDs) {
    SG::IAuxTypeVector* v_dst = nullptr;
    if (id < m_data.m_vecs.size()) {
      v_dst = m_data.m_vecs[id].get();
    }
    if (v_dst && !v_dst->isLinked()) {
      ignore.insert(id);
      if (other.getData(id)) {
        void* src_ptr = other.getData(id, other_size, other_size);
        if (src_ptr) {
          if (!v_dst->insertMove(pos, src_ptr, 0, other_size, other)) {
            nomove = false;
          }
        }
      } else {
        const void* orig = v_dst->toPtr();
        v_dst->shift(pos, other_size);
        if (orig != v_dst->toPtr()) {
          nomove = false;
        }
      }
    }
  }
 
  if (m_data.m_transientStore) {
    if (!m_data.m_transientStore->insertMove(pos, other, ignore))
      nomove = false;
  }
 
  return nomove;
}

isAuxIDSelected()

bool xAOD::details::AuxStoreBase::isAuxIDSelected ( SG::auxid_t auxid ) const

protected

Check if an auxiliary variable is selected for ouput writing.

This is a tricky one.

The function can't just rely on getSelectedAuxIDs, as the aux ID received here may be a new ID that the object doesn't yet know about. So we have no other choice but to check this ID explicitly.

@apram auxid The auxiliary ID that should be checked

Returns

true if the variable needs to be written out, false if not

Definition at line 668 of file AuxStoreBase.cxx.

                                                        {
 
  // A temporary object:
  SG::auxid_set_t auxids;
  auxids.insert(auxid);
 
  // Check if the auxid is returned as a selected ID:
  return m_selection.getSelectedAuxIDs(auxids).size();
}

isDecoration()

bool xAOD::details::AuxStoreBase::isDecoration ( SG::auxid_t auxid ) const

overridevirtual

Test if a variable is a decoration.

Definition at line 199 of file AuxStoreBase.cxx.

                                                     {
  if (m_locked) {
    if (auxid < m_data.m_isDecoration.size() && m_data.m_isDecoration[auxid]) {
      return true;
    }
    if (m_data.m_transientStore) {
      return m_data.m_transientStore->isDecoration(auxid);
    }
  }
  return false;
}

isTopStore()

bool xAOD::details::AuxStoreBase::isTopStore

(

)

const

Check if the object is a "top store", or not.

Definition at line 45 of file AuxStoreBase.cxx.

                                    {
 
  return m_data.m_topStore;
}

linkedVector() [1/2]

const SG::IAuxTypeVector * xAOD::details::AuxStoreBase::linkedVector ( SG::auxid_t auxid ) const

overridevirtual

Return (const) interface for a linked variable.

Definition at line 287 of file AuxStoreBase.cxx.

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

linkedVector() [2/2]

SG::IAuxTypeVector * xAOD::details::AuxStoreBase::linkedVector ( SG::auxid_t auxid )

overridevirtual

Return (non-const) interface for a linked variable.

Reimplemented from SG::IAuxStore.

Definition at line 301 of file AuxStoreBase.cxx.

                                                            {
  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
  SG::auxid_t linked_id = r.linkedVariable(auxid);
  guard_t guard(m_mutex1);
  if (linked_id < m_data.m_vecs.size()) {
    return m_data.m_vecs[linked_id].get();
  }
  if (m_data.m_transientStore) {
    return m_data.m_transientStore->linkedVector(auxid);
  }
  return nullptr;
}

lock()

void xAOD::details::AuxStoreBase::lock ( )

overridevirtual

Lock the object, and don't let decorations be added.

Definition at line 211 of file AuxStoreBase.cxx.

                        {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  m_locked = true;
  if (m_data.m_transientStore) {
    m_data.m_transientStore->lock();
  }
}

lockDecoration()

void xAOD::details::AuxStoreBase::lockDecoration ( SG::auxid_t auxid )

overridevirtual

Lock a decoration.

Definition at line 252 of file AuxStoreBase.cxx.

                                                 {
  if (m_data.m_transientStore) {
    m_data.m_transientStore->lockDecoration(auxid);
  }
  m_data.m_decorIDs.erase(auxid);
}

prefix()

const std::string & xAOD::details::AuxStoreBase::prefix

(

)

const

Get the currently configured object name prefix.

Definition at line 40 of file AuxStoreBase.cxx.

                                            {
 
  return m_data.m_prefix;
}

reserve() [1/2]

virtual void SG::IAuxStore::reserve ( size_t sz )

pure virtualinherited

Change the capacity of all aux data vectors.

Parameters

sz	The new capacity.

This should be called when the capacity of the container changes (by reserve). This should change the capacity for the vectors for all aux data items.

Implemented in xAOD::AuxContainerBase, xAOD::AuxInfoBase, xAOD::ByteStreamAuxContainer_v1, and xAOD::ShallowAuxContainer.

reserve() [2/2]

void xAOD::details::AuxStoreBase::reserve ( std::size_t size )

overridevirtual

Reserve a given size for the arrays.

Definition at line 433 of file AuxStoreBase.cxx.

                                         {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // A sanity check:
  if ((m_data.m_structMode == EStructMode::kObjectStore) && (size != 1)) {
    ::Error("xAOD::AuxStoreBase::reserve",
            XAOD_MESSAGE("size = %i for single-object store"),
            static_cast<int>(size));
    return;
  }
 
  for (auto& v : m_data.m_vecs) {
    if (v && !v->isLinked()) {
      v->reserve(size);
    }
  }
 
  if (m_data.m_transientStore) {
    m_data.m_transientStore->reserve(size);
  }
}

reset()

virtual void xAOD::details::AuxStoreBase::reset ( )

protectedpure virtual

Reset all (transient) information in the object.

Implemented in xAOD::RAuxStore, and xAOD::TAuxStore.

resize() [1/2]

virtual bool SG::IAuxStore::resize ( size_t sz )

pure virtualinherited

Change the size of all aux data vectors.

Parameters

sz	The new size.

This should be called when the size of the container changes. This should resize the vectors for all aux data items.

If the size of the container grows, the new elements should be default-initialized; if it shrinks, destructors should be run as appropriate.

Should return true if it is known that none of the data pointers changed (and thus the cache does not need to be cleared), false otherwise.

Implemented in xAOD::AuxContainerBase, xAOD::AuxInfoBase, xAOD::ByteStreamAuxContainer_v1, and xAOD::ShallowAuxContainer.

resize() [2/2]

bool xAOD::details::AuxStoreBase::resize ( std::size_t size )

overridevirtual

Resize the arrays to a given size.

Definition at line 400 of file AuxStoreBase.cxx.

                                        {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // A sanity check:
  if ((m_data.m_structMode == EStructMode::kObjectStore) && (size != 1)) {
    ::Error("xAOD::AuxStoreBase::resize",
            XAOD_MESSAGE("size = %i for single-object store"),
            static_cast<int>(size));
    return false;
  }
 
  // Remember the new size:
  m_data.m_size = size;
 
  bool nomoves = true;
  for (auto& v : m_data.m_vecs) {
    if (v && !v->isLinked()) {
      if (!v->resize(size)) {
        nomoves = false;
      }
    }
  }
  if (m_data.m_transientStore) {
    if (!m_data.m_transientStore->resize(size)) {
      nomoves = false;
    }
  }
 
  return nomoves;
}

selectAux()

void xAOD::details::AuxStoreBase::selectAux ( const std::set< std::string > & attributes )

virtual

Select dynamic auxiliary attributes for writing.

Definition at line 645 of file AuxStoreBase.cxx.

                                                                {
 
  guard_t guard(m_mutex1);
  m_selection.selectAux(attributes);
}

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; }

setPrefix()

virtual void xAOD::details::AuxStoreBase::setPrefix ( std::string_view prefix )

pure virtual

Set the object name prefix.

Implemented in xAOD::RAuxStore, and xAOD::TAuxStore.

setStructMode()

void xAOD::details::AuxStoreBase::setStructMode

(

EStructMode

mode

)

Set the structure mode of the object to a new value.

Definition at line 34 of file AuxStoreBase.cxx.

                                                 {
 
  m_data.m_structMode = mode;
  reset();
}

setTopStore()

void xAOD::details::AuxStoreBase::setTopStore

(

bool

value = true

)

Set whether the object should behave as a "top store" or not.

Definition at line 50 of file AuxStoreBase.cxx.

                                         {
 
  m_data.m_topStore = value;
  reset();
}

setupInputData()

virtual StatusCode xAOD::details::AuxStoreBase::setupInputData ( SG::auxid_t auxid )

protectedpure virtual

Connect a variable to the input.

Implemented in xAOD::RAuxStore, and xAOD::TAuxStore.

setupOutputData()

virtual StatusCode xAOD::details::AuxStoreBase::setupOutputData ( SG::auxid_t auxid )

protectedpure virtual

Connect a variable to the output.

Implemented in xAOD::RAuxStore, and xAOD::TAuxStore.

shift() [1/2]

virtual void SG::IAuxStore::shift ( size_t pos, ptrdiff_t offs )

pure virtualinherited

Shift the elements of the container.

Parameters

pos	The starting index for the shift.
offs	The (signed) amount of the shift.

This operation shifts the elements in the vectors for all aux data items, to implement an insertion or deletion. offs may be either positive or negative.

If offs is positive, then the container is growing. The container size should be increased by offs, the element at pos moved to pos + offs, and similarly for following elements. The elements between pos and pos + offs should be default-initialized.

If offs is negative, then the container is shrinking. The element at pos should be moved to pos + offs, and similarly for following elements. The container should then be shrunk by -offs elements (running destructors as appropriate).

Implemented in xAOD::AuxContainerBase, xAOD::AuxInfoBase, xAOD::ByteStreamAuxContainer_v1, and xAOD::ShallowAuxContainer.

shift() [2/2]

void xAOD::details::AuxStoreBase::shift ( std::size_t pos, std::ptrdiff_t offs )

overridevirtual

Shift the contents of the stored arrays.

Definition at line 457 of file AuxStoreBase.cxx.

                                                         {
 
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  // A sanity check:
  if (m_data.m_structMode == EStructMode::kObjectStore) {
    ::Error("xAOD::AuxStoreBase::shift",
            XAOD_MESSAGE("Should not have been called for single-object "
                         "store"));
    return;
  }
 
  // Adjust the size of the container:
  if ((static_cast<std::size_t>(std::abs(offs)) > m_data.m_size) &&
      (offs < 0)) {
    m_data.m_size = 0;
  } else {
    m_data.m_size += offs;
  }
 
  for (auto& v : m_data.m_vecs) {
    if (v && !v->isLinked()) {
      v->shift(pos, offs);
    }
  }
 
  if (m_data.m_transientStore) {
    m_data.m_transientStore->shift(pos, offs);
  }
}

size()

std::size_t xAOD::details::AuxStoreBase::size ( ) const

overridevirtual

Return the number of elements in the store.

Definition at line 259 of file AuxStoreBase.cxx.

                                   {
 
  // First, try to find a managed vector in the store:
  for (SG::auxid_t id : m_data.m_auxIDs) {
    // Make sure that we are still within the bounds of our vector:
    if (id >= m_data.m_vecs.size())
      break;
    // Skip non-existent or linked objects:
    if (!m_data.m_vecs[id] || m_data.m_vecs[id]->isLinked()) {
      continue;
    }
    // Ask the vector for its size:
    const std::size_t size = m_data.m_vecs[id]->size();
    // Only accept a non-zero size. Not sure why...
    if (size > 0) {
      return size;
    }
  }
 
  // Check if we have a transient store, and get the size from that:
  if (m_data.m_transientStore) {
    return m_data.m_transientStore->size();
  }
 
  // Apparently the store is empty:
  return 0;
}

structMode()

auto xAOD::details::AuxStoreBase::structMode

(

)

const

Get what structure mode the object was constructed with.

Definition at line 29 of file AuxStoreBase.cxx.

                                                   {
 
  return m_data.m_structMode;
}

toTransient()

void xAOD::details::AuxStoreBase::toTransient ( const EventContext & ctx )

overridevirtual

Call toTransient on contained variables.

Implements SG::IAuxStore.

Definition at line 314 of file AuxStoreBase.cxx.

                                                        {
  // Guard against multi-threaded execution:
  guard_t guard(m_mutex1);
 
  for (auto& v : m_data.m_vecs) {
    if (v) {
      v->toTransient( ctx );
    }
  }
  if (m_data.m_transientStore) {
    m_data.m_transientStore->toTransient(ctx);
  }
}

Member Data Documentation

m_data

Members xAOD::details::AuxStoreBase::m_data

protected

Member variables of the base class.

Definition at line 207 of file AuxStoreBase.h.

m_locked

bool xAOD::details::AuxStoreBase::m_locked = false

private

Is this container locked?

Definition at line 218 of file AuxStoreBase.h.

m_mutex1

mutex_t xAOD::details::AuxStoreBase::m_mutex1

mutableprivate

Mutex objects used for multithreaded synchronisation.

Definition at line 220 of file AuxStoreBase.h.

m_mutex2

mutex_t xAOD::details::AuxStoreBase::m_mutex2

private

Definition at line 220 of file AuxStoreBase.h.

m_selection

AuxSelection xAOD::details::AuxStoreBase::m_selection

private

Object helping to select which auxiliary variables to write.

Definition at line 216 of file AuxStoreBase.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:

• AuxStoreBase.h
• AuxStoreBase.cxx