APRTest::AuxStore Class Reference

#include <AuxStoreTest.h>

Inheritance diagram for APRTest::AuxStore:

Collaboration diagram for APRTest::AuxStore:

Public Member Functions
virtual	~AuxStore ()
virtual void	setStore (IAuxStore *store) override
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 override
	Return the data vector for one aux data item. More...
virtual IAuxStore *	getStore () override
	Return the pointer to the store object currently in use. More...
virtual const IAuxStore *	getStore () const override
virtual AuxStoreType	getStoreType () const override
	Return the type of the store object. More...
virtual size_t	size () const override
	Return the number of elements in the store. More...
bool	standalone () const
	Return the standalone flag. More...
virtual const void *	getData (SG::auxid_t auxid) const=0
	Pick up the const version from the base class. 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 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 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...

Public Attributes
int	m_data = 0

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
enum	AuxStoreType { AST_ObjectStore = 0, AST_ContainerStore = 1 }
	Type of the auxiliary store. More...

Private Member Functions
virtual void *	getDataInternal_noLock (SG::auxid_t auxid, size_t size, size_t capacity, bool no_lock_check)
	Implementation of getDataInternal; no locking. More...
size_t	size_noLock () const
	Return the number of elements in the store; no locking. More...
virtual void	setStore (IAuxStore *store)=0
	Give an auxiliary store object to the holder object. More...

Private Attributes
IAuxStore *	m_extra_store = 0
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 16 of file AuxStoreTest.h.

Member Typedef Documentation

guard_t

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

privateinherited

Definition at line 446 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 445 of file AuxStoreInternal.h.

Member Enumeration Documentation

AuxStoreType

enum SG::IAuxStoreHolder::AuxStoreType

inherited

Type of the auxiliary store.

In the xAOD EDM we use auxiliary store objects in some cases to describe a single object, and in most cases to describe a container of objects. This enumeration declares which type the object implementing this interface is.

Enumerator
AST_ObjectStore	The store describes a single object.
AST_ContainerStore	The store describes a container.

Definition at line 66 of file IAuxStoreHolder.h.

                        {
         AST_ObjectStore    = 0, 
         AST_ContainerStore = 1  
      };

Constructor & Destructor Documentation

~AuxStore()

virtual APRTest::AuxStore::~AuxStore ( )

inlinevirtual

Definition at line 22 of file AuxStoreTest.h.

{}

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 650 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 128 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 555 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 384 of file AuxStoreInternal.cxx.

{
  return m_auxids;
}

getData() [1/3]

const void * APRTest::AuxStore::getData ( SG::auxid_t  auxid ) const

inlineoverridevirtual

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 0 if the item doesn't exist.

Reimplemented from SG::AuxStoreInternal.

Definition at line 53 of file AuxStoreTest.h.

   {
      return m_extra_store?   m_extra_store->getData( auxid)
         : SG::AuxStoreInternal::getData( auxid);
   }

getData() [2/3]

virtual const void* SG::IConstAuxStore::getData

inherited

Pick up the const version from the base class.

getData() [3/3]

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

inlineoverridevirtual

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.

Reimplemented from SG::AuxStoreInternal.

Definition at line 46 of file AuxStoreTest.h.

   {
      return m_extra_store?   m_extra_store->getData( auxid, size, capacity)
         : SG::AuxStoreInternal::getData( auxid, size, capacity);
   }

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

{
  guard_t guard (m_mutex);
  return getDataInternal_noLock (auxid, size, capacity, no_lock_check);
}

getDataInternal_noLock()

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

privatevirtualinherited

Implementation of getDataInternal; no locking.

Definition at line 657 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]->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 182 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();
}

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 526 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 489 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 457 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 424 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 506 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();
  }

getStore() [1/2]

virtual const IAuxStore* APRTest::AuxStore::getStore ( ) const

inlineoverridevirtual

Implements SG::IAuxStoreHolder.

Definition at line 35 of file AuxStoreTest.h.

{ return (IAuxStore*)this; }

getStore() [2/2]

virtual IAuxStore* APRTest::AuxStore::getStore ( )

inlineoverridevirtual

Return the pointer to the store object currently in use.

There's not much use case for this function yet, but it makes the interface complete at least.

Implements SG::IAuxStoreHolder.

Definition at line 34 of file AuxStoreTest.h.

{ return (IAuxStore*)this; }

getStoreType()

virtual AuxStoreType APRTest::AuxStore::getStoreType ( ) const

inlineoverridevirtual

Return the type of the store object.

See also

AuxStoreType

Implements SG::IAuxStoreHolder.

Definition at line 37 of file AuxStoreTest.h.

{ return AST_ContainerStore; }

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 407 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 316 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, reinterpret_cast<char*>(src_ptr) + other_size*r.getEltSize(id),
                                  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;
          (void)getDataInternal_noLock (id, sz, sz, false);
          m_vecs[id]->resize (sz - other_size);
          m_vecs[id]->insertMove (pos, src_ptr, reinterpret_cast<char*>(src_ptr) + other_size*r.getEltSize(id),
                                  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 394 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 762 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 742 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 174 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 538 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 726 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 251 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 227 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 610 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;
}

setStore() [1/2]

virtual void APRTest::AuxStore::setStore ( IAuxStore *  store )

inlineoverridevirtual

Definition at line 25 of file AuxStoreTest.h.

                                                        {
        m_extra_store = store;
     }

setStore() [2/2]

virtual void SG::IAuxStoreHolder::setStore ( IAuxStore *  store )

pure virtualinherited

Give an auxiliary store object to the holder object.

The purpose of this function is to give an alternate store object to this object instead of the one it uses normally.

Parameters

store

Pointer to an object implementing direct ROOT I/O

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

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 285 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()

virtual size_t APRTest::AuxStore::size ( ) const

inlineoverridevirtual

Return the number of elements in the store.

May return 0 for a store with no aux data.

Reimplemented from SG::AuxStoreInternal.

Definition at line 39 of file AuxStoreTest.h.

     { return m_extra_store ? m_extra_store->size() : SG::AuxStoreInternal::size(); }

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 588 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 439 of file AuxStoreInternal.h.

m_data

int APRTest::AuxStore::m_data = 0

Definition at line 20 of file AuxStoreTest.h.

m_decorations

SG::auxid_set_t SG::AuxStoreInternal::m_decorations

privateinherited

Record which variables are decorations.

Definition at line 436 of file AuxStoreInternal.h.

m_extra_store

IAuxStore* APRTest::AuxStore::m_extra_store = 0

private

Definition at line 18 of file AuxStoreTest.h.

m_locked

bool SG::AuxStoreInternal::m_locked

privateinherited

Has this container been locked?

Definition at line 442 of file AuxStoreInternal.h.

m_mutex

mutex_t SG::AuxStoreInternal::m_mutex

mutableprivateinherited

Definition at line 447 of file AuxStoreInternal.h.

m_standalone

bool SG::AuxStoreInternal::m_standalone

privateinherited

Are we being written in standalone mode?

Definition at line 429 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 433 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:

• AuxStoreTest.h