AthenaPoolAuxStore Class Reference

Inheritance diagram for AthenaPoolAuxStore:

Collaboration diagram for AthenaPoolAuxStore:

Public Member Functions
	AthenaPoolAuxStore (bool standalone)
bool	standalone () const
	Return the standalone flag. More...
virtual const void *	getData (SG::auxid_t auxid) const override
	Return the data vector for one aux data item. More...
virtual void *	getData (SG::auxid_t auxid, size_t size, size_t capacity) override
	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 const IAuxTypeVector *	getVector (SG::auxid_t auxid) const override
	Return vector interface for one aux data item. More...
virtual void *	getDecoration (auxid_t auxid, size_t size, size_t capacity) override
	Return the data vector for one aux data decoration item. More...
virtual bool	resize (size_t sz) override
	Change the size of all aux data vectors. More...
virtual void	reserve (size_t sz) override
	Change the capacity of all aux data vectors. More...
virtual void	shift (size_t pos, ptrdiff_t offs) override
	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)) override
	Move all elements from other to this store. More...
virtual const SG::auxid_set_t &	getAuxIDs () const override
	Return a set of identifiers for existing data items in this store. More...
virtual const SG::auxid_set_t &	getDecorIDs () const override
	Return a set of identifiers for decorations in this store. More...
virtual bool	isDecoration (auxid_t auxid) const override
	Test if a particular variable is tagged as a decoration. More...
virtual const SG::auxid_set_t &	getWritableAuxIDs () const override
	Return a set of identifiers for writable data items in this store. More...
virtual const void *	getIOData (SG::auxid_t auxid) const override
	Return a pointer to the data to be stored for one aux data item. More...
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. More...
virtual const SG::auxid_set_t &	getDynamicAuxIDs () const override
	Get the list of all variables that need to be handled. More...
virtual void	lock () override
	Lock the container. More...
virtual bool	clearDecorations () override
	Clear all decorations. More...
virtual size_t	size () const override
	Return the number of elements in the store. More...
virtual bool	setOption (auxid_t id, const AuxDataOption &option) override
	Set an option for an auxiliary data variable. More...
virtual void	lockDecoration (SG::auxid_t auxid) override
	Lock a decoration. More...
virtual IAuxTypeVector *	linkedVector (SG::auxid_t auxid) override
	Return interface for a linked variable. More...
virtual const IAuxTypeVector *	linkedVector (SG::auxid_t auxid) const override
	Return interface for a linked variable. More...
virtual const IAuxTypeVector *	linkedVector (SG::auxid_t) const
	Return interface for a linked variable. More...
virtual SG::auxid_set_t	getSelectedAuxIDs () const
	Get a list of dynamic variables that need to be written out. More...

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

Protected Member Functions
const void *	getIODataInternal (auxid_t auxid, bool quiet) const
	Return a pointer to the data to be stored for one aux data item. More...
void *	getIODataInternal (auxid_t auxid, bool quiet)
	Return a pointer to the data to be stored for one aux data item. More...
void	addAuxID (auxid_t auxid)
	Add a new auxid to the set of those being managed by this store. More...
virtual void *	getDataInternal (SG::auxid_t auxid, size_t size, size_t capacity, bool no_lock_check)
	Return the data vector for one aux data item. More...
void	addVector (std::unique_ptr< IAuxTypeVector > vec, bool isDecoration)
	Explicitly add a vector to the store. More...

Private Types
typedef AthContainers_detail::mutex	mutex_t
	Mutex used to synchronize modifications to the cache vector. More...
typedef AthContainers_detail::lock_guard< mutex_t >	guard_t

Private Member Functions
virtual IAuxTypeVector *	getVectorInternal_noLock (SG::auxid_t auxid, size_t size, size_t capacity, bool no_lock_check)
	Implementation of getVectorInternal; no locking. More...
size_t	size_noLock () const
	Return the number of elements in the store; no locking. More...

Private Attributes
bool	m_standalone
	Are we being written in standalone mode? More...
std::vector< std::unique_ptr< IAuxTypeVector > >	m_vecs
	The collection of vectors of aux data that we're managing, indexed by auxid. More...
SG::auxid_set_t	m_decorations
	Record which variables are decorations. More...
SG::auxid_set_t	m_auxids
	Set of auxid's for which we've created a vector. More...
bool	m_locked
	Has this container been locked? More...
mutex_t	m_mutex

Detailed Description

Definition at line 33 of file AuxDiscoverySvc.cxx.

Member Typedef Documentation

guard_t

typedef AthContainers_detail::lock_guard<mutex_t> SG::AuxStoreInternal::guard_t

privateinherited

Definition at line 461 of file AuxStoreInternal.h.

mutex_t

typedef AthContainers_detail::mutex SG::AuxStoreInternal::mutex_t

privateinherited

Mutex used to synchronize modifications to the cache vector.

Definition at line 460 of file AuxStoreInternal.h.

Constructor & Destructor Documentation

AthenaPoolAuxStore()

AthenaPoolAuxStore::AthenaPoolAuxStore ( bool  standalone )

inline

Definition at line 35 of file AuxDiscoverySvc.cxx.

: SG::AuxStoreInternal(standalone) {}

Member Function Documentation

addAuxID()

void SG::AuxStoreInternal::addAuxID ( auxid_t  auxid )

protectedinherited

Add a new auxid to the set of those being managed by this store.

Parameters

auxid

The auxid to add.

Definition at line 676 of file AuxStoreInternal.cxx.

{
  m_auxids.insert (auxid);
}

addVector()

void SG::AuxStoreInternal::addVector ( std::unique_ptr< IAuxTypeVector >  vec, bool  isDecoration  )

protectedinherited

Explicitly add a vector to the store.

Parameters

vec	Vector data being added.
isDecoration	Should this variable be marked as a decoration?

For internal use. The auxid must not already exist in the store.

Definition at line 144 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  auxid_t auxid = vec->auxid();
  if (m_locked)
    throw ExcStoreLocked (auxid);
 
  // Resize the vector if needed.
  if (m_vecs.size() <= auxid) {
    m_vecs.resize (auxid+1);
  }
 
  // Give up if the variable is already present in the store.
  if (m_vecs[auxid]) std::abort();
 
  // Make sure the length is consistent with the rest of the store.
  if (!vec->isLinked()) {
    size_t sz = this->size_noLock();
    if (vec->size() < sz)
      vec->resize (sz);
  }
 
  // Add it to the store.
  m_vecs[auxid] = std::move (vec);
  addAuxID (auxid);
  if (isDecoration) {
    m_decorations.insert (auxid);
  }
}

clearDecorations()

bool SG::AuxStoreInternal::clearDecorations ( )

overridevirtualinherited

Clear all decorations.

Erase all decorations from the store, restoring the state to when lock was called. Be sure to clear the cache of the referencing container!

Returns true if there were any decorations that were cleared, false if the store did not contain any decorations.

Implements SG::IConstAuxStore.

Definition at line 581 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  bool anycleared = false;
  for (auxid_t id : m_decorations) {
    m_vecs[id].reset();
    m_auxids.erase (id);
    anycleared = true;
  }
  if (anycleared) {
    m_decorations.clear();
  }
  return anycleared;
}

getAuxIDs()

const SG::auxid_set_t & SG::AuxStoreInternal::getAuxIDs ( ) const

overridevirtualinherited

Return a set of identifiers for existing data items in this store.

This should include identifiers for all items, const and non-const.

Implements SG::IConstAuxStore.

Definition at line 400 of file AuxStoreInternal.cxx.

{
  return m_auxids;
}

getData() [1/3]

const void * SG::AuxStoreInternal::getData ( SG::auxid_t  auxid ) const

overridevirtualinherited

Return the data vector for one aux data item.

Parameters

auxid

The identifier of the desired aux data item.

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.

This should return nullptr if the item doesn't exist.

Implements SG::IConstAuxStore.

Reimplemented in APRTest::AuxStore, and RootAuxDynStore.

Definition at line 83 of file AuxStoreInternal.cxx.

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

getData() [2/3]

virtual const void* SG::IConstAuxStore::getData

inherited

Pick up the const version from the base class.

getData() [3/3]

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

overridevirtualinherited

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.

Implements SG::IAuxStore.

Reimplemented in APRTest::AuxStore, and RootAuxDynStore.

Definition at line 130 of file AuxStoreInternal.cxx.

{
  return getDataInternal (auxid, size, capacity, false);
}

getDataInternal()

void * SG::AuxStoreInternal::getDataInternal ( SG::auxid_t  auxid, size_t  size, size_t  capacity, bool  no_lock_check  )

protectedvirtualinherited

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).
no_lock_check	If true, then skip the test for a locked container.

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.

Definition at line 735 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  return getVectorInternal_noLock (auxid, size, capacity, no_lock_check)->toPtr();
}

getDecoration()

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

overridevirtualinherited

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.

Implements SG::IConstAuxStore.

Reimplemented in RootAuxDynStore.

Definition at line 198 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  if (m_vecs.size() <= auxid) {
    m_vecs.resize (auxid+1);
  }
  if (m_vecs[auxid] == 0) {
    m_vecs[auxid] = AuxTypeRegistry::instance().makeVector (auxid, size, capacity);
    addAuxID (auxid);
    std::unique_ptr<IAuxTypeVector> linked = m_vecs[auxid]->linkedVector();
    auxid_t linked_id = null_auxid;
    if (linked) {
      linked_id = linked->auxid();
      m_vecs[linked_id] = std::move (linked);
      addAuxID (linked_id);
    }
    if (m_locked) {
      m_decorations.insert (auxid);
      if (linked_id != null_auxid) {
        m_decorations.insert (linked_id);
      }
    }
  }
  if (m_locked && !m_decorations.test (auxid)) {
    throw ExcStoreLocked (auxid);
  }
  return m_vecs[auxid]->toPtr();
}

getDecorIDs()

const SG::auxid_set_t & SG::AuxStoreInternal::getDecorIDs ( ) const

overridevirtualinherited

Return a set of identifiers for decorations in this store.

Implements SG::IConstAuxStore.

Definition at line 410 of file AuxStoreInternal.cxx.

{
  return m_decorations;
}

getDynamicAuxIDs()

const SG::auxid_set_t & SG::AuxStoreInternal::getDynamicAuxIDs ( ) const

overridevirtualinherited

Get the list of all variables that need to be handled.

Implements SG::IAuxStoreIO.

Definition at line 552 of file AuxStoreInternal.cxx.

{
  return getAuxIDs();
}

getIOData()

const void * SG::AuxStoreInternal::getIOData ( SG::auxid_t  auxid ) const

overridevirtualinherited

Return a pointer to the data to be stored for one aux data item.

Parameters

auxid

The identifier of the desired aux data item.

This will usually be a pointer to a std::vector; however, it may be something different for a standalone object.

Returns 0 and reports an error if the requested aux data item does not exist.

Implements SG::IAuxStoreIO.

Reimplemented in RootAuxDynStore.

Definition at line 515 of file AuxStoreInternal.cxx.

{
  return getIODataInternal (auxid, false);
}

getIODataInternal() [1/2]

void * SG::AuxStoreInternal::getIODataInternal ( auxid_t  auxid, bool  quiet  )

protectedinherited

Return a pointer to the data to be stored for one aux data item.

Parameters

auxid	The identifier of the desired aux data item.
quiet	If true, then don't print an error on failure.

This will usually be a pointer to a std::vector; however, it may be something different for a standalone object.

Returns 0 and reports an error if the requested aux data item does not exist.

Definition at line 483 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  if (auxid >= m_vecs.size() || !m_vecs[auxid]) {
    if (!quiet) {
      std::ostringstream ss;
      ss  << "Requested variable "
          << SG::AuxTypeRegistry::instance().getName (auxid)
          << " (" << auxid << ") doesn't exist";
      ATHCONTAINERS_ERROR("AuxStoreInternal::getIODataInternal", ss.str());
    }
    return 0;
  }
 
  if (m_standalone) {
    if (!SG::AuxTypeRegistry::instance().isLinked (auxid))
      return m_vecs[auxid]->toPtr();
  }
  return m_vecs[auxid]->toVector();
}

getIODataInternal() [2/2]

const void * SG::AuxStoreInternal::getIODataInternal ( auxid_t  auxid, bool  quiet  ) const

protectedinherited

Return a pointer to the data to be stored for one aux data item.

Parameters

auxid	The identifier of the desired aux data item.
quiet	If true, then don't print an error on failure.

This will usually be a pointer to a std::vector; however, it may be something different for a standalone object.

Returns 0 and reports an error if the requested aux data item does not exist.

Definition at line 450 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  if (auxid >= m_vecs.size() || !m_vecs[auxid]) {
    if (!quiet) {
      std::ostringstream ss;
      ss  << "Requested variable "
          << SG::AuxTypeRegistry::instance().getName (auxid)
          << " (" << auxid << ") doesn't exist";
      ATHCONTAINERS_ERROR("AuxStoreInternal::getIODataInternal", ss.str());
    }
    return 0;
  }
 
  if (m_standalone) {
    if (!SG::AuxTypeRegistry::instance().isLinked (auxid))
      return m_vecs[auxid]->toPtr();
  }
  return m_vecs[auxid]->toVector();
}

getIOType()

const std::type_info * SG::AuxStoreInternal::getIOType ( SG::auxid_t  auxid ) const

overridevirtualinherited

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

Parameters

auxid

The identifier of the desired aux data item.

For an aux data item of type T, this will usually be std::vector<T>. For standalone objects, however, it will usually be T; and std::vector<char> will be used instead of std::vector<bool>.

Returns 0 if the requested aux data item does not exist.

Implements SG::IAuxStoreIO.

Definition at line 532 of file AuxStoreInternal.cxx.

{
  if (m_standalone) {
    const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
    if (!r.isLinked (auxid))
      return r.getType (auxid);
  }
  guard_t guard (m_mutex);
  if (auxid < m_vecs.size() && m_vecs[auxid]) {
    const std::type_info* ret = m_vecs[auxid]->objType();
    if (ret) return ret;
  }
  return SG::AuxTypeRegistry::instance().getVecType (auxid);
}

getSelectedAuxIDs()

virtual SG::auxid_set_t SG::IAuxStoreIO::getSelectedAuxIDs ( ) const

inlinevirtualinherited

Get a list of dynamic variables that need to be written out.

Reimplemented in xAOD::TAuxStore, xAOD::AuxContainerBase, xAOD::ShallowAuxContainer, and xAOD::AuxInfoBase.

Definition at line 86 of file IAuxStoreIO.h.

                                                  {
     // default all are selected
     return getDynamicAuxIDs();
  }

getVector()

const IAuxTypeVector * SG::AuxStoreInternal::getVector ( SG::auxid_t  auxid ) const

overridevirtualinherited

Return vector interface for one aux data item.

Parameters

auxid

The identifier of the desired aux data item.

This should return nullptr if the item doesn't exist.

Implements SG::IConstAuxStore.

Reimplemented in RootAuxDynStore.

Definition at line 99 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  if (auxid >= m_vecs.size() || !m_vecs[auxid]) {
    // With the new behavior of SG::Accessor::isAvailable,
    // we shouldn't print an error message here. Asking the store whether
    // it has an element using this function is not necessarily an
    // error condition by now. In any case, the DataVector code will
    // complain itself in case of an error.
    return 0;
  }
  return m_vecs[auxid].get();
}

getVectorInternal_noLock()

IAuxTypeVector * SG::AuxStoreInternal::getVectorInternal_noLock ( SG::auxid_t  auxid, size_t  size, size_t  capacity, bool  no_lock_check  )

privatevirtualinherited

Implementation of getVectorInternal; no locking.

Definition at line 684 of file AuxStoreInternal.cxx.

{
  if (m_vecs.size() <= auxid) {
    m_vecs.resize (auxid+1);
  }
  if (m_vecs[auxid] == 0) {
    if (m_locked && !no_lock_check)
      throw ExcStoreLocked (auxid);
    const AuxTypeRegistry& r = AuxTypeRegistry::instance();
    m_vecs[auxid] = r.makeVector (auxid, size, capacity);
    addAuxID (auxid);
    std::unique_ptr<IAuxTypeVector> linked = m_vecs[auxid]->linkedVector();
    if (linked) {
      auxid_t linked_id = linked->auxid();
      m_vecs[linked_id] = std::move (linked);
      addAuxID (linked_id);
    }
  }
  else {
    // Make sure the vector has at least the requested size.
    // One way in which it could be short: setOption was called and created
    // a variable in a store that had no other variables.
    if (m_vecs[auxid]->size() < size) {
      m_vecs[auxid]->resize (size);
      m_vecs[auxid]->reserve (capacity);
    }
  }
  return m_vecs[auxid].get();
}

getWritableAuxIDs()

const SG::auxid_set_t & SG::AuxStoreInternal::getWritableAuxIDs ( ) const

overridevirtualinherited

Return a set of identifiers for writable data items in this store.

This should include only non-const identifiers.

Implements SG::IAuxStore.

Definition at line 433 of file AuxStoreInternal.cxx.

{
  return getAuxIDs();
}

insertMove()

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

overridevirtualinherited

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.

Implements SG::IAuxStore.

Definition at line 332 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  const AuxTypeRegistry& r = AuxTypeRegistry::instance();
 
  if (m_locked)
    throw ExcStoreLocked ("insertMove");
  bool nomove = true;
  size_t other_size = other.size();
  if (other_size == 0)
    return true;
  for (SG::auxid_t id : m_auxids) {
    SG::IAuxTypeVector* v_dst = nullptr;
    if (id < m_vecs.size())
      v_dst = m_vecs[id].get();
    // Skip linked vars --- they should be taken care of by the parent var.
    if (v_dst && !v_dst->isLinked()) {
      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;
      }
    }
  }
 
  // Add any new variables not present in the original container.
  for (SG::auxid_t id : other.getAuxIDs()) {
    if (!m_auxids.test(id) && !ignore.test(id))
    {
      if (r.isLinked (id)) continue;
      if (other.getData (id)) {
        void* src_ptr = other.getData (id, other_size, other_size);
        if (src_ptr) {
          size_t sz = size_noLock();
          if (sz < other_size) sz = other_size + pos;
          IAuxTypeVector* v = getVectorInternal_noLock (id, sz, sz, false);
          v->resize (sz - other_size);
          v->insertMove (pos, src_ptr, 0, other_size,
                         other);
          nomove = false;
        }
      }
    }
  }
  
  return nomove;
}

isDecoration()

bool SG::AuxStoreInternal::isDecoration ( auxid_t  auxid ) const

overridevirtualinherited

Test if a particular variable is tagged as a decoration.

Parameters

auxid

The identifier of the desired aux data item.

Implements SG::IConstAuxStore.

Reimplemented in RootAuxDynStore.

Definition at line 420 of file AuxStoreInternal.cxx.

{
  return m_decorations.test (auxid);
}

linkedVector() [1/3]

const IAuxTypeVector * SG::AuxStoreInternal::linkedVector ( SG::auxid_t  auxid ) const

overridevirtualinherited

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.

Reimplemented from SG::IConstAuxStore.

Definition at line 789 of file AuxStoreInternal.cxx.

{
  const AuxTypeRegistry& r = AuxTypeRegistry::instance();
  auxid_t linked_id = r.linkedVariable (auxid);
  guard_t guard (m_mutex);
  if (linked_id < m_vecs.size())
    return m_vecs[linked_id].get();
  return nullptr;
}

linkedVector() [2/3]

IAuxTypeVector * SG::AuxStoreInternal::linkedVector ( SG::auxid_t  auxid )

overridevirtualinherited

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.

Reimplemented from SG::IAuxStore.

Definition at line 769 of file AuxStoreInternal.cxx.

{
  const AuxTypeRegistry& r = AuxTypeRegistry::instance();
  auxid_t linked_id = r.linkedVariable (auxid);
  guard_t guard (m_mutex);
  if (linked_id < m_vecs.size())
    return m_vecs[linked_id].get();
  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 SG::AuxStoreInternal::lock ( )

overridevirtualinherited

Lock the container.

After this, only decorations can be changed/modified. If the container is already locked, this is a no-op.

Implements SG::IConstAuxStore.

Definition at line 564 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  m_locked = true;
}

lockDecoration()

void SG::AuxStoreInternal::lockDecoration ( SG::auxid_t  auxid )

overridevirtualinherited

Lock a decoration.

Parameters

auxid

Identifier of the decoration to lock.

A decoration is locked by changing from a decoration to an ordinary variable. If the container itself is locked, then modifications to the variable are not permitted after this call.

Implements SG::IConstAuxStore.

Definition at line 753 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  m_decorations.reset (auxid);
}

reserve()

void SG::AuxStoreInternal::reserve ( size_t  sz )

overridevirtualinherited

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.

Implements SG::IAuxStore.

Definition at line 267 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  if (m_locked)
    throw ExcStoreLocked ("reserve");
  for (std::unique_ptr<IAuxTypeVector>& v : m_vecs) {
    if (v && !v->isLinked())
      v->reserve (sz);
  }
}

resize()

bool SG::AuxStoreInternal::resize ( size_t  sz )

overridevirtualinherited

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.

Implements SG::IAuxStore.

Definition at line 243 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  if (m_locked)
    throw ExcStoreLocked ("resize");
  bool nomoves = true;
  for (std::unique_ptr<IAuxTypeVector>& v : m_vecs) {
    if (v && !v->isLinked()) {
      if (!v->resize (sz))
        nomoves = false;
    }
  }
  return nomoves;
}

setOption()

bool SG::AuxStoreInternal::setOption ( auxid_t  id, const AuxDataOption &  option  )

overridevirtualinherited

Set an option for an auxiliary data variable.

Parameters

id	The variable for which we want to set the option.
option	The option setting to make.

The interpretation of option depends on the associated auxiliary store. See PackedParameters.h for option settings for writing packed data. Returns true on success, false otherwise.

Reimplemented from SG::IAuxStore.

Definition at line 636 of file AuxStoreInternal.cxx.

{
  // Does this variable exist in this store?
  bool exists = false;
  {
    guard_t guard (m_mutex);
    if (id < m_vecs.size() && m_vecs[id] != 0)
      exists = true;
  }
 
  // If not, and we have a packing parameter request, then create the variable.
  if (!exists) {
    if (!PackedParameters::isValidOption (option)) return false;
    size_t sz = size();
    getDataInternal (id, sz, sz, true);
  }
 
  // Try the option setting.
  guard_t guard (m_mutex);
  if (m_vecs[id]->setOption (option)) return true;
 
  // It didn't work.  If this is a packing request, then try to convert
  // the variable to packed form and retry.
  if (!PackedParameters::isValidOption (option)) return false;
  std::unique_ptr<IAuxTypeVector> packed = m_vecs[id]->toPacked();
  if (packed) {
    // Converted to packed form.  Replace the object and retry.
    m_vecs[id] = std::move (packed);
    return m_vecs[id]->setOption (option);
  }
 
  // Didn't work.
  return false;
}

shift()

void SG::AuxStoreInternal::shift ( size_t  pos, ptrdiff_t  offs  )

overridevirtualinherited

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

Implements SG::IAuxStore.

Definition at line 301 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  if (m_locked)
    throw ExcStoreLocked ("shift");
  for (std::unique_ptr<IAuxTypeVector>& v : m_vecs) {
    if (v && !v->isLinked())
      v->shift (pos, offs);
  }
}

size()

size_t SG::AuxStoreInternal::size ( ) const

overridevirtualinherited

Return the number of elements in the store.

May return 0 for a store with no aux data.

Implements SG::IConstAuxStore.

Reimplemented in RootAuxDynStore, and APRTest::AuxStore.

Definition at line 602 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  return size_noLock();
}

size_noLock()

size_t SG::AuxStoreInternal::size_noLock ( ) const

privateinherited

Return the number of elements in the store; no locking.

Return the number of elements in the store.

(No locking.)

May return 0 for a store with no aux data.

Definition at line 614 of file AuxStoreInternal.cxx.

{
  for (SG::auxid_t id : m_auxids) {
    if (id < m_vecs.size() && m_vecs[id] && !m_vecs[id]->isLinked() &&
        m_vecs[id]->size() > 0)
    {
      return m_vecs[id]->size();
    }
  }
  return 0;
}

standalone()

bool SG::AuxStoreInternal::standalone ( ) const

inherited

Return the standalone flag.

Definition at line 67 of file AuxStoreInternal.cxx.

{
  return m_standalone;
}

Member Data Documentation

m_auxids

SG::auxid_set_t SG::AuxStoreInternal::m_auxids

privateinherited

Set of auxid's for which we've created a vector.

Definition at line 454 of file AuxStoreInternal.h.

m_decorations

SG::auxid_set_t SG::AuxStoreInternal::m_decorations

privateinherited

Record which variables are decorations.

Definition at line 451 of file AuxStoreInternal.h.

m_locked

bool SG::AuxStoreInternal::m_locked

privateinherited

Has this container been locked?

Definition at line 457 of file AuxStoreInternal.h.

m_mutex

mutex_t SG::AuxStoreInternal::m_mutex

mutableprivateinherited

Definition at line 462 of file AuxStoreInternal.h.

m_standalone

bool SG::AuxStoreInternal::m_standalone

privateinherited

Are we being written in standalone mode?

Definition at line 444 of file AuxStoreInternal.h.

m_vecs

std::vector<std::unique_ptr<IAuxTypeVector> > SG::AuxStoreInternal::m_vecs

privateinherited

The collection of vectors of aux data that we're managing, indexed by auxid.

Definition at line 448 of file AuxStoreInternal.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 file:

• AuxDiscoverySvc.cxx