SG::AuxStoreInternal Class Reference

An auxiliary data store that holds data internally. More...

#include <AuxStoreInternal.h>

Inheritance diagram for SG::AuxStoreInternal:

Collaboration diagram for SG::AuxStoreInternal:

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

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

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.
void *	getIODataInternal (auxid_t auxid, bool quiet)
	Return a pointer to the data to be stored for one aux data item.
void	addAuxID (auxid_t auxid)
	Add a new auxid to the set of those being managed by this store.
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.
void	addVector (std::unique_ptr< IAuxTypeVector > vec, bool isDecoration)
	Explicitly add a vector to the store.

Private Types
typedef AthContainers_detail::mutex	mutex_t
	Mutex used to synchronize modifications to the cache vector.
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.
size_t	size_noLock () const
	Return the number of elements in the store; no locking.

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

Detailed Description

An auxiliary data store that holds data internally.

When auxiliary data are associated with a container, the data themselves are managed by a separate ‘store’ object, described by the interfaces SG::IAuxStore and SG::IConstAuxStore.

This class is an implementation of those interfaces that stores the data itself. This is suitable, for example, for transient auxiliary data.

Definition at line 41 of file AuxStoreInternal.h.

Member Typedef Documentation

guard_t

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

private

Definition at line 461 of file AuxStoreInternal.h.

mutex_t

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

private

Mutex used to synchronize modifications to the cache vector.

Definition at line 460 of file AuxStoreInternal.h.

Constructor & Destructor Documentation

AuxStoreInternal() [1/2]

SG::AuxStoreInternal::AuxStoreInternal

(

bool

standalone = false

)

Constructor.

Parameters

standalone

If true, then write this in standalone mode.

Definition at line 30 of file AuxStoreInternal.cxx.

  : m_standalone (standalone),
    m_locked (false)
{
}

~AuxStoreInternal()

SG::AuxStoreInternal::~AuxStoreInternal ( )

virtual

Destructor.

All contained data will be deleted.

Definition at line 42 of file AuxStoreInternal.cxx.

{
}

AuxStoreInternal() [2/2]

SG::AuxStoreInternal::AuxStoreInternal

(

const AuxStoreInternal &

orig

)

Copy constructor.

Definition at line 50 of file AuxStoreInternal.cxx.

{
  guard_t guard (other.m_mutex);
  m_standalone = other.m_standalone;
  m_decorations = other.m_decorations;
  m_auxids = other.m_auxids;
  m_locked = other.m_locked;
  size_t size = other.m_vecs.size();
  m_vecs.resize (size);
  for (size_t i = 0; i < size; i++) {
    if (other.m_vecs[i])
      m_vecs[i] = other.m_vecs[i]->clone();
  }
}

Member Function Documentation

addAuxID()

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

protected

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

Parameters

auxid

The auxid to add.

Definition at line 690 of file AuxStoreInternal.cxx.

{
  m_auxids.insert (auxid);
}

addVector()

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

protected

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 146 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);
 
  // Need to be sure that the addition to the decoration bitset is visible
  // to other threads before the addition to the variable bitset.
  if (isDecoration) {
    m_decorations.insert (auxid);
    std::atomic_thread_fence (std::memory_order_seq_cst);
  }
  addAuxID (auxid);
}

clearDecorations()

bool SG::AuxStoreInternal::clearDecorations ( )

overridevirtual

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 595 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

overridevirtual

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 414 of file AuxStoreInternal.cxx.

{
  return m_auxids;
}

getData() [1/2]

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

overridevirtual

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 85 of file AuxStoreInternal.cxx.

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

getData() [2/2]

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

overridevirtual

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

protectedvirtual

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

overridevirtual

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 204 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);
    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);
    }
    if (m_locked) {
      // Need to be sure that the addition to the decoration bitset is visible
      // to other threads before the addition to the variable bitset.
      m_decorations.insert (auxid);
      if (linked_id != null_auxid) {
        m_decorations.insert (linked_id);
      }
      std::atomic_thread_fence (std::memory_order_seq_cst);
    }
    addAuxID (auxid);
    if (linked_id != null_auxid) {
      addAuxID (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

overridevirtual

Return a set of identifiers for decorations in this store.

Implements SG::IConstAuxStore.

Definition at line 424 of file AuxStoreInternal.cxx.

{
  return m_decorations;
}

getDynamicAuxIDs()

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

overridevirtual

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

Implements SG::IAuxStoreIO.

Definition at line 566 of file AuxStoreInternal.cxx.

{
  return getAuxIDs();
}

getIOData()

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

overridevirtual

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 529 of file AuxStoreInternal.cxx.

{
  return getIODataInternal (auxid, false);
}

getIODataInternal() [1/2]

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

protected

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 497 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

protected

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 464 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

overridevirtual

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 546 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::AuxContainerBase, xAOD::AuxInfoBase, xAOD::details::AuxStoreBase, and xAOD::ShallowAuxContainer.

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

overridevirtual

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

privatevirtual

Implementation of getVectorInternal; no locking.

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

overridevirtual

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

overridevirtual

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 346 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);
          (void)v->insertMove (pos, src_ptr, 0, other_size,
                               other);
          nomove = false;
        }
      }
    }
  }
  
  return nomove;
}

isDecoration()

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

overridevirtual

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 434 of file AuxStoreInternal.cxx.

{
  return m_decorations.test (auxid);
}

linkedVector() [1/2]

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

overridevirtual

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 803 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/2]

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

overridevirtual

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

lock()

void SG::AuxStoreInternal::lock ( )

overridevirtual

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 578 of file AuxStoreInternal.cxx.

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

lockDecoration()

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

overridevirtual

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 767 of file AuxStoreInternal.cxx.

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

operator=()

AuxStoreInternal & SG::AuxStoreInternal::operator= ( const AuxStoreInternal & )

delete

Don't allow assignment.

reserve()

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

overridevirtual

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

overridevirtual

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 254 of file AuxStoreInternal.cxx.

{
  guard_t guard (m_mutex);
  if (m_locked)
    throw ExcStoreLocked ("resize");
  bool nomoves = true;
  for (SG::auxid_t id : m_auxids) {
    SG::IAuxTypeVector* v = nullptr;
    if (id < m_vecs.size())
      v = m_vecs[id].get();
    if (v && !v->isLinked()) {
      if (!v->resize (sz))
        nomoves = false;
    }
  }
  return nomoves;
}

setOption()

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

overridevirtual

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

overridevirtual

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 315 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

overridevirtual

Return the number of elements in the store.

May return 0 for a store with no aux data.

Implements SG::IConstAuxStore.

Reimplemented in APRTest::AuxStore, and RootAuxDynStore.

Definition at line 616 of file AuxStoreInternal.cxx.

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

size_noLock()

size_t SG::AuxStoreInternal::size_noLock ( ) const

private

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 628 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

Return the standalone flag.

Definition at line 69 of file AuxStoreInternal.cxx.

{
  return m_standalone;
}

Member Data Documentation

m_auxids

SG::auxid_set_t SG::AuxStoreInternal::m_auxids

private

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

private

Record which variables are decorations.

Definition at line 451 of file AuxStoreInternal.h.

m_locked

bool SG::AuxStoreInternal::m_locked

private

Has this container been locked?

Definition at line 457 of file AuxStoreInternal.h.

m_mutex

mutex_t SG::AuxStoreInternal::m_mutex

mutableprivate

Definition at line 462 of file AuxStoreInternal.h.

m_standalone

bool SG::AuxStoreInternal::m_standalone

private

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

private

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

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

---

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

• AuxStoreInternal.h
• AuxStoreInternal.cxx