RootAuxDynStore Class Reference

#include <RootAuxDynStore.h>

Inheritance diagram for RootAuxDynStore:

Collaboration diagram for RootAuxDynStore:

Public Member Functions
	RootAuxDynStore (RootAuxDynReader &reader, long long entry, bool standalone, std::recursive_mutex *iomtx=nullptr)
virtual	~RootAuxDynStore ()
virtual const void *	getData (SG::auxid_t auxid) const override
	implementation of the IAuxStore interface
virtual const SG::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 const void *	getIOData (SG::auxid_t auxid) const override
	implementation of the IAuxStoreIO interface
virtual void *	getDecoration (SG::auxid_t auxid, size_t size, size_t capacity) override
	Return the data vector for one aux data decoration item.
virtual bool	isDecoration (SG::auxid_t auxid) const override
	Test if a particular variable is tagged as a decoration.
virtual size_t	size () const override
	Return the number of elements in the store.
bool	standalone () const
	Return the standalone flag.
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 const SG::auxid_set_t &	getWritableAuxIDs () const override
	Return a set of identifiers for writable data items in this store.
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 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 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

Protected Member Functions
virtual bool	readData (SG::auxid_t auxid)=0
	read data from ROOT and store it in m_vecs. Returns False on error
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.

Protected Attributes
long long	m_entry
mutex_t	m_mutex
std::recursive_mutex *	m_iomutex
	Optional mutex used to serialize I/O with RootStorageSvc (not owned)

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?

Detailed Description

Definition at line 16 of file RootAuxDynStore.h.

Member Typedef Documentation

guard_t

typedef AthContainers_detail::lock_guard<mutex_t> RootAuxDynStore::guard_t

protected

Definition at line 67 of file RootAuxDynStore.h.

mutex_t

typedef AthContainers_detail::mutex RootAuxDynStore::mutex_t

protected

Mutex used to synchronize modifications to the cache vector.

Definition at line 66 of file RootAuxDynStore.h.

Constructor & Destructor Documentation

RootAuxDynStore()

RootAuxDynStore::RootAuxDynStore	(	RootAuxDynReader &	reader,
		long long	entry,
		bool	standalone,
		std::recursive_mutex *	iomtx = nullptr )

Definition at line 12 of file RootAuxDynStore.cxx.

  : SG::AuxStoreInternal( standalone ),
    m_entry(entry),
    m_iomutex(iomtx)
{
   for( auto id : reader.auxIDs() ) {
      addAuxID(id);
   }
   lock();
}

~RootAuxDynStore()

virtual RootAuxDynStore::~RootAuxDynStore ( )

inlinevirtual

Definition at line 22 of file RootAuxDynStore.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 690 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 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 ( )

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

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

{
  return m_auxids;
}

getData() [1/2]

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

overridevirtual

implementation of the IAuxStore interface

Reimplemented from SG::AuxStoreInternal.

Definition at line 25 of file RootAuxDynStore.cxx.

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

getData() [2/2]

void * RootAuxDynStore::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.

Reimplemented from SG::AuxStoreInternal.

Definition at line 50 of file RootAuxDynStore.cxx.

{
  // MN: how do we add new attributes to this store?  A:for now we don't
  throw("Non-const access to RootAuxDynStore is not supported");
}

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

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

getDecoration()

void * RootAuxDynStore::getDecoration ( SG::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).
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.

The base class implementation works except for the case where we have not yet created a vector for an item in the root file. We need to detect that case and raise an exception.

Reimplemented from SG::AuxStoreInternal.

Definition at line 87 of file RootAuxDynStore.cxx.

{
  guard_t guard (m_mutex);
  if (SG::AuxStoreInternal::getIODataInternal (auxid, true) == 0 &&
      SG::AuxStoreInternal::getAuxIDs().count (auxid) > 0)
  {
    throw SG::ExcStoreLocked (auxid);
  }
  return SG::AuxStoreInternal::getDecoration (auxid, size, capacity);
}

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

{
  return getAuxIDs();
}

getIOData()

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

overridevirtual

implementation of the IAuxStoreIO interface

Reimplemented from SG::AuxStoreInternal.

Definition at line 57 of file RootAuxDynStore.cxx.

{
  guard_t guard (m_mutex);
  const void* ret = SG::AuxStoreInternal::getIODataInternal (auxid, true);
  if (!ret) {
    auto this_nc ATLAS_THREAD_SAFE = const_cast<RootAuxDynStore*>(this); // locked above
    if( this_nc->readData(auxid) ) {
       ret = SG::AuxStoreInternal::getIOData (auxid);
    }
  }
  return ret;
}

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

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

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 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 SG::IAuxTypeVector * RootAuxDynStore::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.

Reimplemented from SG::AuxStoreInternal.

Definition at line 35 of file RootAuxDynStore.cxx.

{
  guard_t guard (m_mutex);
  // lock
  const SG::IAuxTypeVector* ret = SG::AuxStoreInternal::getVector (auxid);
  if (!ret) {
    auto this_nc ATLAS_THREAD_SAFE = const_cast<RootAuxDynStore*>(this); // locked above
    if( this_nc->readData(auxid) ) {
       ret = SG::AuxStoreInternal::getVector (auxid);
    }
  }
  return ret;
}

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

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

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 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 RootAuxDynStore::isDecoration ( SG::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.
auxid	The identifier of the desired aux data item.

See getDecoration() above.

Reimplemented from SG::AuxStoreInternal.

Definition at line 105 of file RootAuxDynStore.cxx.

{
  guard_t guard( m_mutex );
  if (SG::AuxStoreInternal::getIODataInternal (auxid, true) == 0 &&
      SG::AuxStoreInternal::getAuxIDs().count (auxid) > 0)
  {
    return false;
  }
  return SG::AuxStoreInternal::isDecoration (auxid);
}

linkedVector() [1/2]

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

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

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

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

readData()

virtual bool RootAuxDynStore::readData ( SG::auxid_t auxid )

protectedpure virtual

read data from ROOT and store it in m_vecs. Returns False on error

Implemented in RNTupleAuxDynStore, and TBranchAuxDynStore.

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

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

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

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 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 RootAuxDynStore::size ( ) const

overridevirtual

Return the number of elements in the store.

May return 0 for a store with no aux data.

NOTE: this method will attempt to read data if size unknown (0) May return 0 for a store with no aux data.

Reimplemented from SG::AuxStoreInternal.

Definition at line 121 of file RootAuxDynStore.cxx.

{
  const std::size_t s = SG::AuxStoreInternal::size();
  if( s != 0 ) {
    return s;
  }
 
  for( SG::auxid_t id : getAuxIDs() ) {
    if( getData( id ) != nullptr ) {
      return SG::AuxStoreInternal::size();
    }
  }
 
  return 0;
}

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

inherited

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

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_entry

long long RootAuxDynStore::m_entry

protected

Definition at line 63 of file RootAuxDynStore.h.

m_iomutex

std::recursive_mutex* RootAuxDynStore::m_iomutex

protected

Optional mutex used to serialize I/O with RootStorageSvc (not owned)

Definition at line 71 of file RootAuxDynStore.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 RootAuxDynStore::m_mutex

mutableprotected

Definition at line 68 of file RootAuxDynStore.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

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:

• RootAuxDynStore.h
• RootAuxDynStore.cxx