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	EStructMode { EStructMode::kUndefinedStore = 0, EStructMode::kContainerStore = 1, EStructMode::kObjectStore = 2 }
	"Structural" modes of the object More...

Public Member Functions
	AuxStoreBase (bool topStore=true, EStructMode mode=EStructMode::kUndefinedStore)
	Constructor. More...
virtual	~AuxStoreBase ()
	Destructor. More...
EStructMode	structMode () const
	Get what structure mode the object was constructed with. More...
void	setStructMode (EStructMode mode)
	Set the structure mode of the object to a new value. More...
const std::string &	prefix () const
	Get the currently configured object name prefix. More...
virtual void	setPrefix (std::string_view prefix)=0
	Set the object name prefix. More...
bool	isTopStore () const
	Check if the object is a "top store", or not. More...
void	setTopStore (bool value=true)
	Set whether the object should behave as a "top store" or not. More...
virtual void *	getData (auxid_t auxid, size_t size, size_t capacity)=0
	Return the data vector for one aux data item. More...
virtual const void *	getData (SG::auxid_t auxid) const=0
	Pick up the const version from the base class. More...
virtual bool	resize (size_t sz)=0
	Change the size of all aux data vectors. More...
virtual void	reserve (size_t sz)=0
	Change the capacity of all aux data vectors. More...
virtual void	shift (size_t pos, ptrdiff_t offs)=0
	Shift the elements of the container. 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...
virtual const IAuxTypeVector *	linkedVector (SG::auxid_t) const
	Return interface for a linked variable. More...
virtual void *	getDecoration (auxid_t auxid, size_t size, size_t capacity)=0
	Return the data vector for one aux data decoration item. More...

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

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

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

Protected Attributes
Members	m_data
	Member variables of the base class. More...

Private Attributes
AuxSelection	m_selection
	Object helping to select which auxiliary variables to write. More...
bool	m_locked = false
	Is this container locked? More...
mutex_t	m_mutex1
	Mutex objects used for multithreaded synchronisation. More...
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 206 of file AuxStoreBase.h.

mutex_t

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

protected

Mutex type for multithread synchronization.

Definition at line 204 of file AuxStoreBase.h.

Member Enumeration Documentation

EStructMode

enum 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 22 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.

Implements SG::IConstAuxStore.

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

Implements SG::IConstAuxStore.

Definition at line 99 of file AuxStoreBase.cxx.

                                                   {
 
  return m_data.m_auxIDs;
}

getData() [1/4]

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 SG::AuxStoreInternal, APRTest::AuxStore, RootAuxDynStore, xAOD::AuxContainerBase, xAOD::ShallowAuxContainer, xAOD::AuxInfoBase, and xAOD::ByteStreamAuxContainer_v1.

getData() [2/4]

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

overridevirtual

Get a pointer to a given array.

Implements SG::IConstAuxStore.

Definition at line 54 of file AuxStoreBase.cxx.

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

getData() [3/4]

virtual const void* SG::IConstAuxStore::getData

inherited

Pick up the const version from the base class.

getData() [4/4]

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 299 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() [1/2]

virtual void* SG::IConstAuxStore::getDecoration ( auxid_t  auxid, size_t  size, size_t  capacity  )

pure virtualinherited

Return the data vector for one aux data decoration 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 then it will be created and initialized with default values. If the container is locked, then the new item will be marked as a decoration. size and capacity give the size for the new aux data item vector.

If the data item already exists, then we return it if either the container is not locked or the item is marked as a decoration. Otherwise we throw an exception.

Implemented in xAOD::EventAuxInfo_v1, xAOD::EventInfoAuxContainer_v1, xAOD::EventAuxInfo_v2, xAOD::EventAuxInfo_v3, RootAuxDynStore, SG::AuxStoreInternal, xAOD::AuxContainerBase, xAOD::ShallowAuxContainer, xAOD::AuxInfoBase, SG::AuxStoreConstMem, and xAOD::ByteStreamAuxContainer_v1.

getDecoration() [2/2]

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 109 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())) {
      m_data.m_auxIDs.insert(auxid);
      if (m_data.m_transientStore->isDecoration(auxid)) {
        m_data.m_decorIDs.insert(auxid);
      }
    }
    // Return the memory address from the transient store:
    return result;
  }
 
  // Doesn't exist yet. So let's make it:
  void* result = getData(auxid, size, capacity);
  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);
  }
 
  // 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.

Implements SG::IConstAuxStore.

Definition at line 104 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 608 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::TAuxStore, and xAOD::RAuxStore.

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::TAuxStore, and xAOD::RAuxStore.

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::TAuxStore, and xAOD::RAuxStore.

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 510 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 569 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 623 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.

Implements SG::IConstAuxStore.

Definition at line 63 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;
  }
 
  // Return the pointer to the object:
  return m_data.m_vecs[auxid].get();
}

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 366 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::TAuxStore, and xAOD::RAuxStore.

hasOutput()

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

protectedpure virtual

Check if an output is being written by the object.

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

insertMove() [1/2]

virtual bool SG::IAuxStore::insertMove ( size_t  pos, IAuxStore &  other, const SG::auxid_set_t &  ignore = SG::auxid_set_t()  )

pure virtualinherited

Move all elements from other to this store.

Parameters

pos	The starting index of the insertion.
other	Store from which to do the move.
ignore	Set of variables that should not be added to the store.

Let len be the size of other. The store will be increased in size by len elements, with the elements at pos being copied to pos+len. Then, for each auxiliary variable, the entire contents of that variable for other will be moved to this store at index pos. This will be done via move semantics if possible; otherwise, it will be done with a copy. Variables present in this store but not in other will have the corresponding elements default-initialized. Variables in other but not in this store will be added unless they are in ignore.

Returns true if it is known that none of the vectors' memory moved, false otherwise.

Implemented in SG::AuxStoreInternal.

insertMove() [2/2]

bool xAOD::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 460 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 639 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.

Implements SG::IConstAuxStore.

Definition at line 184 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 43 of file AuxStoreBase.cxx.

                                    {
 
  return m_data.m_topStore;
}

linkedVector() [1/3]

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

overridevirtual

Return (const) interface for a linked variable.

Reimplemented from SG::IConstAuxStore.

Definition at line 272 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/3]

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

linkedVector() [3/3]

virtual const IAuxTypeVector* SG::IConstAuxStore::linkedVector

inlineinherited

Return interface for a linked variable.

Parameters

auxid

The ID of the parent variable.

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

Definition at line 189 of file IConstAuxStore.h.

  { return nullptr; }

lock()

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

overridevirtual

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

Implements SG::IConstAuxStore.

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

Implements SG::IConstAuxStore.

Definition at line 237 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 38 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 SG::AuxStoreInternal, xAOD::AuxContainerBase, xAOD::ShallowAuxContainer, xAOD::AuxInfoBase, and xAOD::ByteStreamAuxContainer_v1.

reserve() [2/2]

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

overridevirtual

Reserve a given size for the arrays.

Definition at line 404 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::TAuxStore, and xAOD::RAuxStore.

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 SG::AuxStoreInternal, xAOD::AuxContainerBase, xAOD::ShallowAuxContainer, xAOD::AuxInfoBase, and xAOD::ByteStreamAuxContainer_v1.

resize() [2/2]

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

overridevirtual

Resize the arrays to a given size.

Definition at line 371 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 616 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, xAOD::AuxInfoBase, and SG::AuxStoreInternal.

Definition at line 173 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 32 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 48 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::TAuxStore, and xAOD::RAuxStore.

setupOutputData()

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

protectedpure virtual

Connect a variable to the output.

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

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 SG::AuxStoreInternal, xAOD::AuxContainerBase, xAOD::ShallowAuxContainer, xAOD::AuxInfoBase, and xAOD::ByteStreamAuxContainer_v1.

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

Implements SG::IConstAuxStore.

Definition at line 244 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 27 of file AuxStoreBase.cxx.

                                                   {
 
  return m_data.m_structMode;
}

Member Data Documentation

m_data

Members xAOD::details::AuxStoreBase::m_data

protected

Member variables of the base class.

Definition at line 201 of file AuxStoreBase.h.

m_locked

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

private

Is this container locked?

Definition at line 212 of file AuxStoreBase.h.

m_mutex1

mutex_t xAOD::details::AuxStoreBase::m_mutex1

mutableprivate

Mutex objects used for multithreaded synchronisation.

Definition at line 214 of file AuxStoreBase.h.

m_mutex2

mutex_t xAOD::details::AuxStoreBase::m_mutex2

private

Definition at line 214 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 210 of file AuxStoreBase.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 199 of file IAuxStore.h.

---

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

• AuxStoreBase.h
• AuxStoreBase.cxx