SG::AuxVectorBase Class Reference

Manage index tracking and synchronization of auxiliary data. More...

#include <AuxVectorBase.h>

Inheritance diagram for SG::AuxVectorBase:

Collaboration diagram for SG::AuxVectorBase:

Classes
class	ResortAuxHelper
	Helper to factor out template-independent part of resortAux. More...

Public Types
template<class T>
using	span = typename AuxDataTraits<T>::span
	Spans over auxiliary variables.
template<class T>
using	const_span = typename AuxDataTraits<T>::const_span

Public Member Functions
	AuxVectorBase ()
	Default constructor.
	AuxVectorBase (AuxVectorBase &&rhs)
	Move constructor.
AuxVectorBase &	operator= (AuxVectorBase &&rhs)
	Move assignment.
virtual	~AuxVectorBase ()
	Destructor.
bool	trackIndices () const
	Return true if index tracking is enabled for this container.
void	setStore (SG::IAuxStore *store)
	Set the store associated with this object.
void	setStore (const SG::IConstAuxStore *store)
	Set the store associated with this object.
void	setStore (const DataLink< SG::IConstAuxStore > &store)
	Set the store associated with this object.
void	setConstStore (const SG::IConstAuxStore *store)
	Synonym for setStore with IConstAuxStore.
void	setNonConstStore (SG::IAuxStore *store)
	Synonym for setStore with IAuxStore.
template<class T>
bool	isAvailable (const std::string &name, const std::string &clsname="") const
	Test to see if a variable exists in the store.
template<class T>
bool	isAvailableWritable (const std::string &name, const std::string &clsname="")
	Test to see if a variable is available for writing.
template<class T>
bool	isAvailableWritableAsDecoration (const std::string &name, const std::string &clsname="") const
	Test to see if a variable is available for writing as a decoration.
template<class T>
span< T >	getDataSpan (const std::string &name)
	Return a span over an aux data item.
template<class T>
const_span< T >	getDataSpan (const std::string &name) const
	Return a span over an aux data item.
template<class T>
const_span< T >	getConstDataSpan (const std::string &name) const
	Return a span over an aux data item.
template<class T>
span< T >	getDecorationSpan (const std::string &name) const
	Return a span over an aux data item for a decoration.
bool	isAvailable (auxid_t id) const
	Test to see if a variable exists in the store.
bool	isAvailableWritable (auxid_t id)
	Test to see if a variable is available for writing.
bool	isAvailableWritableAsDecoration (auxid_t id) const
	Test to see if a variable is available for writing as a decoration.
virtual size_t	size_v () const =0
	Return the size of the container.
virtual size_t	capacity_v () const =0
	Return the capacity of the container.
Aux store management.
const SG::IConstAuxStore *	getConstStore () const
	Return the current store, as a const interface.
const DataLink< SG::IConstAuxStore >	getConstStoreLink () const
	Return the data link to the current store, as a const interface.
SG::IAuxStore *	getStore ()
	Return the current store, as a non-const interface.
const SG::IAuxStore *	getStore () const
	Return the current store, as a non-const interface.
bool	hasStore () const
	Return true if this object has an associated store.
bool	hasNonConstStore () const
	Return true if this object has an associated non-const store.
bool	setOption (auxid_t id, const AuxDataOption &option)
	Set an option for an auxiliary data variable.
bool	setOption (const std::string &name, const AuxDataOption &option)
	Set an option for an auxiliary data variable.
bool	setOption (const std::string &name, const std::string &clsname, const AuxDataOption &option)
	Set an option for an auxiliary data variable.
template<class T>
bool	setOption (auxid_t id, const std::string &optname, T arg)
	Set an option for an auxiliary data variable.
bool	setOption (const std::string &name, const std::string &optname, int arg)
	Set an option for an auxiliary data variable.
bool	setOption (const std::string &name, const std::string &optname, float arg)
bool	setOption (const std::string &name, const std::string &optname, double arg)
template<class T>
bool	setOption (const std::string &name, const std::string &clsname, const std::string &optname, T arg)
	Set an option for an auxiliary data variable.

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

Protected Member Functions
template<class DVL>
void	initAuxVectorBase (SG::OwnershipPolicy ownPolicy, SG::IndexTrackingPolicy indexTrackingPolicy)
	Initialize index tracking mode.
void	swap (AuxVectorBase &other)
	Swap with another container.
template<class ForwardIterator>
void	setIndices (ForwardIterator beg, ForwardIterator end, size_t first=0)
	Set container/index for all elements within a range.
template<class ForwardIterator>
void	clearIndex (ForwardIterator elt)
	Clear the container / index for element elt.
template<class ForwardIterator>
void	clearIndices (ForwardIterator beg, ForwardIterator end)
	Clear the container / index for a range of elements.
template<class DVL>
void	resize (size_t size)
	Resize the aux data associated with this container.
template<class DVL>
void	reserve (size_t size)
	Change the capacity of the aux data associated with this container.
template<class DVL>
void	shift (DVL &cont, size_t pos, ptrdiff_t offs)
	Shift the elements of the container.
void	moveAux (size_t index, SG::AuxElement *p, bool clear=false, bool skipDestClear=false)
	Set index on an element and copy auxiliary data.
void	moveAux (size_t index, const void *p, bool clear=false, bool skipDestClear=false)
	Set index on an element and copy auxiliary data.
template<class ForwardIterator>
void	moveAux (size_t index, ForwardIterator beg, ForwardIterator end, bool clear=false, bool skipDestClear=false)
	Set index on a range of elements and copy auxiliary data.
void	swapElementsAux (size_t aindex, size_t bindex, SG::AuxElement *a, SG::AuxElement *b, AuxVectorBase *bcont)
	Swap indices and auxiliary data between two elements.
void	swapElementsAux (size_t aindex, size_t bindex, const void *a, const void *b, AuxVectorBase *bcont)
	Swap indices and auxiliary data between two elements.
template<class ForwardIterator>
void	resortAux (size_t index, ForwardIterator beg, ForwardIterator end)
	Reset indices / reorder aux data after elements have been permuted.

Private Member Functions
void	initAuxVectorBase1 (const std::false_type &, SG::OwnershipPolicy, SG::IndexTrackingPolicy)
	Initialize index tracking mode — no-auxdata specialization.
void	initAuxVectorBase1 (const std::true_type &, SG::OwnershipPolicy ownPolicy, SG::IndexTrackingPolicy indexTrackingPolicy)
	Initialize index tracking mode — auxdata specialization.
template<class ForwardIterator>
void	setIndices1 (const std::false_type &, ForwardIterator beg, ForwardIterator end, size_t first)
	Set container/index for all elements within a range.
template<class ForwardIterator>
void	setIndices1 (const std::true_type &, ForwardIterator beg, ForwardIterator end, size_t first)
	Set container/index for all elements within a range.
template<class ForwardIterator>
void	clearIndex1 (const std::false_type &, ForwardIterator elt)
	Clear the container / index for element elt.
template<class ForwardIterator>
void	clearIndex1 (const std::true_type &, ForwardIterator elt)
	Clear the container / index for element elt.
template<class ForwardIterator>
void	clearIndices1 (const std::false_type &, ForwardIterator, ForwardIterator)
	Clear the container / index for a range of elements.
template<class ForwardIterator>
void	clearIndices1 (const std::true_type &, ForwardIterator beg, ForwardIterator end)
	Clear the container / index for a range of elements.
void	resize1 (const std::false_type &, size_t size)
	Resize the aux data associated with this container.
void	resize1 (const std::true_type &, size_t size)
	Resize the aux data associated with this container.
void	reserve1 (const std::false_type &, size_t size)
	Change the capacity of the aux data associated with this container.
void	reserve1 (const std::true_type &, size_t size)
	Change the capacity of the aux data associated with this container.
template<class DVL>
void	shift1 (const std::false_type &, DVL &cont, size_t pos, ptrdiff_t offs)
	Shift the elements of the container.
template<class DVL>
void	shift1 (const std::true_type &, DVL &cont, size_t pos, ptrdiff_t offs)
	Shift the elements of the container.
template<class ForwardIterator>
void	moveAux1 (const std::false_type &, size_t index, ForwardIterator beg, ForwardIterator end, bool clear=false, bool skipDestClear=false)
	Set index on a range of elements and copy auxiliary data.
template<class ForwardIterator>
void	moveAux1 (const std::true_type &, size_t index, ForwardIterator beg, ForwardIterator end, bool clear=false, bool skipDestClear=false)
	Set index on a range of elements and copy auxiliary data.
template<class ForwardIterator>
void	resortAux1 (const std::false_type &, size_t index, ForwardIterator beg, ForwardIterator end)
	Reset indices / reorder aux data after elements have been permuted.
template<class ForwardIterator>
void	resortAux1 (const std::true_type &, size_t index, ForwardIterator a, ForwardIterator b)
	Reset indices / reorder aux data after elements have been permuted.
void *	getDataArrayForResort (SG::auxid_t auxid)
void	setIndexForResort (SG::AuxElement *elt, size_t idx)

Private Attributes
bool	m_trackIndices
	Flag if index tracking is enabled.

Friends
class	ResortAuxHelper

Other operations.
Cache m_cache	ATLAS_THREAD_SAFE
	Cached pointers to the start of aux data vectors, non-const.
Cache m_constCache	ATLAS_THREAD_SAFE
	Cached pointers to the start of aux data vectors, const.
Cache m_decorCache	ATLAS_THREAD_SAFE
	Cached pointers to the start of aux data vectors, decorations.
Cache m_spanCache	ATLAS_THREAD_SAFE
	Cached pointers to span descriptors.
SG::IAuxStore *	m_store
	Associated store, non-const.
const SG::IConstAuxStore *	m_constStore
	Associated store, const.
DataLink< SG::IConstAuxStore >	m_constStoreLink
	Associated store link, const.
mutex_t	m_mutex
void	swap (AuxVectorData &other)
	Swap this instance with another.
void	clearCache ()
	Clear the cached aux data pointers.
void	clearCache (SG::auxid_t auxid)
	Clear the cached aux data pointers for a single variable.
void	clearDecorCache (SG::auxid_t auxid)
	Clear the cached decoration pointer for a single variable.
virtual void	lock () override
	Lock the container.
bool	clearDecorations () const
	Clear all decorations.
void	lockDecoration (SG::auxid_t auxid)
	Explicitly lock a decoration.
const SG::IConstAuxStore *	getConstStoreOol () const
	Same as getConstStore.
void	setCache (SG::auxid_t auxid, void *ptr)
	Explicitly set a cache pointer.
void	setCache (SG::auxid_t auxid, const void *ptr)
	Explicitly set a cache pointer.
bool	isAvailableOol (auxid_t id) const
	Out-of-line portion of isAvailable.
bool	isAvailableWritableOol (auxid_t id)
	Out-of-line portion of isAvailableWritable.
bool	isAvailableWritableAsDecorationOol (auxid_t id) const
	Out-of-line portion of isAvailableWritableAsDecoration.
void *	getDataOol (SG::auxid_t auxid, bool allowMissing)
	Out-of-line portion of data access.
const void *	getDataOol (SG::auxid_t auxid, bool allowMissing) const
	Out-of-line portion of data access (const version).
void *	getDecorationOol (SG::auxid_t auxid) const
	Out-of-line portion of data access (decorator version).
const AuxDataSpanBase *	getDataSpanOol (SG::auxid_t auxid, bool allowMissing) const
	Return a reference to a description of this vector's start+size, out-of-line portion.
typedef AthContainers_detail::mutex	mutex_t
	Mutex used to synchronize modifications to the cache vector.
typedef AthContainers_detail::lock_guard< mutex_t >	guard_t
static const SG::auxid_set_t	s_emptySet
	Empty auxid set, used for a return value when we have no associated store.

Data access.
const SG::auxid_set_t &	getAuxIDs () const
	Return a set of identifiers for existing data items in store associated with this object.
const SG::auxid_set_t &	getDecorIDs () const
	Return a set of identifiers for decorations for this object.
const SG::auxid_set_t &	getWritableAuxIDs () const
	Return a set of identifiers for writable data items in this store.
template<class T>
AuxDataTraits< T >::reference_type	getData (SG::auxid_t auxid, size_t ndx)
	Return reference to an aux data item.
template<class T>
AuxDataTraits< T >::const_reference_type	getData (SG::auxid_t auxid, size_t ndx) const
	Return const reference to an aux data item.
template<class T>
AuxDataTraits< T >::reference_type	getDecoration (SG::auxid_t auxid, size_t ndx) const
	Return reference to an aux decoration item.
const void *	getDataArray (SG::auxid_t auxid) const
	Return a const pointer to the start of an aux data vector.
void *	getDataArray (SG::auxid_t auxid)
	Return a pointer to the start of an aux data vector.
const void *	getDataArrayAllowMissing (SG::auxid_t auxid) const
	Return a const pointer to the start of an aux data vector.
void *	getDecorationArray (SG::auxid_t auxid) const
	Return a pointer to the start of an aux data vector for a decoration.
const AuxDataSpanBase *	getDataSpan (SG::auxid_t auxid) const
	Return a reference to a description of this vector's start+size.
static size_t s_minCacheLen	ATLAS_THREAD_SAFE
	Minimum length to use for the cache vector.

Detailed Description

Manage index tracking and synchronization of auxiliary data.

An object, usually a DataVector, can have vectors of auxiliary data associated with it. In order to be able to find the auxiliary data for a given container element, the elements must hold their indices within the container (done by the AuxElement class).

When the container changes, this information must be updated. Indices need to be changed, and corresponding changes need to be made in the vectors of associated auxiliary data. Most of the code in this class consists of helpers that effect these changes. These are intended to be called only by the deriving container class.

This class also contains a flag to control whether or not indices should be tracked like this. This is controlled by the type of the payload and by the selected ownership and indexing policies.

If the payload type does not derive from SG::AuxElement, then no index tracking is possible, and the flag is always false.

Otherwise, it depends on the setting of the policies. The default value for the index tracking policy is DEFAULT_TRACK_INDICES. In that case, we track indices if this container owns its elements (OWN_ELEMENTS) and we don't if the container does not down its elements (VIEW_ELEMENTS). This is the usual case. However, the index tracking policy may also be set to ALWAYS_TRACK_INDICES or NEVER_TRACK_INDICES to override this. (The major foreseen use case for this is to allow index tracking for a view container populated with objects allocated from a DataPool.)

The derived container should initialize this class by calling initAuxVectorBase. The derived container class is passed as a template argument; the ownership and index tracking policies are also passed. This method can be called again if the policies change.

There are only a couple user-callable methods. The trackIndices method returns the current state of the index tracking flag. There are also wrappers for setStore method, which enforce the condition that one can't set a store for a container that does not do index tracking.

The remaining methods are intended to be called only from the derived container class (and thus they are declared as protected). Besides a swap method, these include

• setIndices, to reset the indices within a range to sequential values.
• clearIndex, to clear the index / container for a single element.
• clearIndices, to clear the index / container for elements within a range.
• resize, to change the size of the aux data.
• reserve, to change the capacity of the aux data.
• shift, to shift a range of aux data up or down, to track insertions or deletions from within the container.
• moveAux, to be used when an element or range of elements is moved into the container.
• swapElementsAux, to swap aux data for two elements, possibly in different containers.
• resortAux, to rearrange indices and aux data correctly after an operation that permuted the elements of the container.

Definition at line 96 of file AuxVectorBase.h.

Member Typedef Documentation

const_span

template<class T>

using SG::AuxVectorBase::const_span = typename AuxDataTraits<T>::const_span

Definition at line 102 of file AuxVectorBase.h.

guard_t

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

privateinherited

Definition at line 986 of file AuxVectorData.h.

mutex_t

typedef AthContainers_detail::mutex SG::AuxVectorData::mutex_t

privateinherited

Mutex used to synchronize modifications to the cache vector.

Definition at line 985 of file AuxVectorData.h.

span

template<class T>

using SG::AuxVectorBase::span = typename AuxDataTraits<T>::span

Spans over auxiliary variables.

Definition at line 101 of file AuxVectorBase.h.

Constructor & Destructor Documentation

AuxVectorBase() [1/2]

SG::AuxVectorBase::AuxVectorBase

(

)

Default constructor.

This will disable index tracking by default. The constructor should be followed by a call to initAuxVectorBase. (This is separated from the constructor because calling non-default constructors of DataVector base classes can be awkward in the case of virtual derivation.)

Definition at line 27 of file AuxVectorBase.cxx.

  : m_trackIndices (false)
{
}

AuxVectorBase() [2/2]

SG::AuxVectorBase::AuxVectorBase

(

AuxVectorBase &&

rhs

)

Move constructor.

Parameters

rhs	The container from which to move.

Definition at line 37 of file AuxVectorBase.cxx.

  : AuxVectorData (std::move (rhs)),
    m_trackIndices (rhs.m_trackIndices)
{
}

~AuxVectorBase()

SG::AuxVectorBase::~AuxVectorBase ( )

virtual

Destructor.

Definition at line 61 of file AuxVectorBase.cxx.

{
}

Member Function Documentation

capacity_v()

virtual size_t SG::AuxVectorData::capacity_v ( ) const

pure virtualinherited

Return the capacity of the container.

This is used when we need to create a new aux data vector.

Implemented in SG::AuxElementData, and SG::AuxVectorInterface.

clearCache() [1/2]

void SG::AuxVectorData::clearCache ( )

inherited

Clear the cached aux data pointers.

You should call this any time something changes in the aux store that could invalidate the vector pointers.

clearCache() [2/2]

void SG::AuxVectorData::clearCache ( SG::auxid_t auxid )

inherited

Clear the cached aux data pointers for a single variable.

Parameters

auxid

ID of the variable to clear.

Not really safe to use if another thread may be accessing the same decoration.

clearDecorations()

bool SG::AuxVectorData::clearDecorations ( ) const

inherited

Clear all decorations.

Erase all decorations from the store, restoring the state to when lock was called.

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

Definition at line 653 of file AuxVectorData.cxx.

{
  bool ret = false;
  if (m_store) {
    // Avoid warning about calling non-const function.  OK here.
    IAuxStore* store ATLAS_THREAD_SAFE = m_store;
    ret = store->clearDecorations();
    m_cache.clear();
    m_constCache.clear();
    m_decorCache.clear();
  }
  else if (getConstStore()) {
    // The whole point of decorations is to allow adding information to
    // something that's otherwise const.  So we have the const_cast here.
    // The store object is responsible for determining whether the
    // modification is really allowed or not.
    IConstAuxStore* store ATLAS_THREAD_SAFE =
       const_cast<IConstAuxStore*> (getConstStore());
    ret = store->clearDecorations();
  }
  else
    throw SG::ExcNoAuxStore ("lock");
  return ret;
}

clearDecorCache()

void SG::AuxVectorData::clearDecorCache ( SG::auxid_t auxid )

inherited

Clear the cached decoration pointer for a single variable.

Parameters

auxid

ID of the variable to clear.

Not really safe to use if another thread may be accessing the same decoration.

clearIndex()

template<class ForwardIterator>

void SG::AuxVectorBase::clearIndex ( ForwardIterator elt )

protected

Clear the container / index for element elt.

Parameters

elt	Iterator to the element to clear.

ForwardIterator should be an iterator over the DataVector (not a base iterator).

clearIndex1() [1/2]

template<class ForwardIterator>

void SG::AuxVectorBase::clearIndex1 ( const std::false_type & , ForwardIterator elt )

private

Clear the container / index for element elt.

Parameters

elt	Iterator to the element to clear.

This is the no-auxdata case; doesn't do anything other than checking m_trackIndices.

clearIndex1() [2/2]

template<class ForwardIterator>

void SG::AuxVectorBase::clearIndex1 ( const std::true_type & , ForwardIterator elt )

private

Clear the container / index for element elt.

Parameters

elt	Iterator to the element to clear.

This is the auxdata case.

clearIndices()

template<class ForwardIterator>

void SG::AuxVectorBase::clearIndices ( ForwardIterator beg, ForwardIterator end )

protected

Clear the container / index for a range of elements.

Parameters

beg	Beginning of the range.
end	End of the range.

ForwardIterator should be an iterator over the DataVector (not a base iterator).

clearIndices1() [1/2]

template<class ForwardIterator>

void SG::AuxVectorBase::clearIndices1 ( const std::false_type & , ForwardIterator , ForwardIterator  )

private

Clear the container / index for a range of elements.

Parameters

beg	Beginning of the range.
end	End of the range.

No-auxdata case; a no-op except for checking m_trackIndices.

clearIndices1() [2/2]

template<class ForwardIterator>

void SG::AuxVectorBase::clearIndices1 ( const std::true_type & , ForwardIterator beg, ForwardIterator end )

private

Clear the container / index for a range of elements.

Parameters

beg	Beginning of the range.
end	End of the range.

Auxdata case.

getAuxIDs()

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

inherited

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

This will include identifiers for all items, const and non-const. If no store is associated with this object, this will return an empty set.

Definition at line 203 of file AuxVectorData.cxx.

{
  const SG::IConstAuxStore* store = getConstStore();
  if (store)
    return store->getAuxIDs();
  return s_emptySet;
}

getConstDataSpan()

template<class T>

const_span< T > SG::AuxVectorBase::getConstDataSpan

(

const std::string &

name

)

const

Return a span over an aux data item.

Parameters

auxid

The desired aux data item.

This will return a span containing the value of the requested auxiliary variable for all elements in the container. If the item doesn't exist, it will be created. Errors are signaled by raising an exception. Note that the value_type of the span is not necessarily T; an example is bool for which we return a span of char.

getConstStore()

const SG::IConstAuxStore * SG::AuxVectorData::getConstStore ( ) const

inherited

Return the current store, as a const interface.

This will be non-zero if either a const or non-const store is associated with this object.

getConstStoreLink()

const DataLink< SG::IConstAuxStore > SG::AuxVectorData::getConstStoreLink ( ) const

inherited

Return the data link to the current store, as a const interface.

This is set by persistency when reading an object, but it may be overridden by setting the store pointer directly.

getConstStoreOol()

const SG::IConstAuxStore * SG::AuxVectorData::getConstStoreOol ( ) const

inherited

Same as getConstStore.

But out-of-line, as sometimes the debugger has problems calling inline functions.

Definition at line 704 of file AuxVectorData.cxx.

{
  return getConstStore();
}

getData() [1/2]

template<class T>

AuxDataTraits< T >::reference_type SG::AuxVectorData::getData ( SG::auxid_t auxid, size_t ndx )

inherited

Return reference to an aux data item.

Parameters

auxid	The desired aux data item.
ndx	Index of the element to return.

This will return a reference to element ndx of aux data item auxid. If the aux data item does not exist, it will be created. Errors are signaled by raising an exception.

Warning: no type checking is done. You should usually access the data via Accessor or ConstAccessor.

getData() [2/2]

template<class T>

AuxDataTraits< T >::const_reference_type SG::AuxVectorData::getData ( SG::auxid_t auxid, size_t ndx ) const

inherited

Return const reference to an aux data item.

Parameters

auxid	The desired aux data item.
ndx	Index of the element to return.

This will return a reference to element ndx of aux data item auxid. Errors are signaled by raising an exception.

Warning: no type checking is done. You should usually access the data via Accessor or ConstAccessor.

getDataArray() [1/2]

void * SG::AuxVectorData::getDataArray ( SG::auxid_t auxid )

inherited

Return a pointer to the start of an aux data vector.

Parameters

auxid

The desired aux data item.

This will return a pointer to the start of the data for aux data item auxid. If the item doesn't exist, it will be created. Errors are signaled by raising an exception.

getDataArray() [2/2]

const void * SG::AuxVectorData::getDataArray ( SG::auxid_t auxid ) const

inherited

Return a const pointer to the start of an aux data vector.

Parameters

auxid

The desired aux data item.

This will return a pointer to the start of the data for aux data item auxid. Errors are signaled by raising an exception.

getDataArrayAllowMissing()

const void * SG::AuxVectorData::getDataArrayAllowMissing ( SG::auxid_t auxid ) const

inherited

Return a const pointer to the start of an aux data vector.

Parameters

auxid

The desired aux data item.

This will return a pointer to the start of the data for aux data item auxid. If the item does not exist, this will return nullptr rather than raising an exception.

getDataArrayForResort()

void * SG::AuxVectorBase::getDataArrayForResort ( SG::auxid_t auxid )

private

getDataOol() [1/2]

void * SG::AuxVectorData::getDataOol ( SG::auxid_t auxid, bool allowMissing )

privateinherited

Out-of-line portion of data access.

Parameters

auxid	aux data item being accessed.
allowMissing	If true, then return nullptr if the variable is missing rather than throwing an exception.

When this function returns, the cache entry m_cache[auxid] will be valid. That entry is also returned. If there's an error, the function will throw an exception rather than returning.

Definition at line 308 of file AuxVectorData.cxx.

{
  guard_t guard (m_mutex);
 
  // Fetch the pointer from the store, or raise an exception if we don't
  // have a non-const store.
  void* ptr = 0;
  if (m_store) {
    if (SG::AuxTypeRegistry::instance().isLinked (auxid)) {
      ptr = m_store->getData (auxid, 0, 0);
    }
    else {
      ptr = m_store->getData (auxid, this->size_v(), this->capacity_v());
    }
  }
  else if (getConstStore())
    throw SG::ExcConstAuxData ("fetch item", auxid);
  else
    throw SG::ExcNoAuxStore (auxid);
 
  // Check that we got a good pointer back, otherwise throw.
  if (ptr) {
    m_cache.store (auxid, ptr);
 
    // Set the same entry in the other caches as well.
    m_constCache.store (auxid, ptr);
    m_decorCache.store (auxid, ptr);
  }
  else if (!allowMissing)
    throw SG::ExcBadAuxVar (auxid);
 
  return ptr;
}

getDataOol() [2/2]

const void * SG::AuxVectorData::getDataOol ( SG::auxid_t auxid, bool allowMissing ) const

privateinherited

Out-of-line portion of data access (const version).

Parameters

auxid	aux data item being accessed.
allowMissing	If true, then return nullptr if the variable is missing rather than throwing an exception.

When this function returns, the cache entry m_constCache[auxid] will be valid. That entry is also returned. If there's an error, the function will throw an exception rather than returning.

Definition at line 353 of file AuxVectorData.cxx.

{
  guard_t guard (m_mutex);
 
  // Fetch the pointer from the store, or raise an exception if we don't
  // have a const store.
  const void* ptr = 0;
  const SG::IConstAuxStore* store = getConstStore();
  if (store)
    ptr = store->getData (auxid);
  else
    throw SG::ExcNoAuxStore (auxid);
 
  // Check that we got a good pointer back, otherwise throw.
  if (ptr) {
    // We could avoid the const_cast here by having distinct const and
    // non-const Cache types, holding const void* and void*, respectively.
    // However, since this is a purely internal class that users don't
    // deal with directly, that's not worth the bother (and the extra code).
    void* vp ATLAS_THREAD_SAFE = const_cast<void*> (ptr);
    m_constCache.store (auxid, vp);
  }
  else if (!allowMissing)
    throw SG::ExcBadAuxVar (auxid);
 
  return ptr;
}

getDataSpan() [1/3]

template<class T>

span< T > SG::AuxVectorBase::getDataSpan

(

const std::string &

name

)

Return a span over an aux data item.

Parameters

auxid

The desired aux data item.

This will return a span containing the value of the requested auxiliary variable for all elements in the container. If the item doesn't exist, it will be created. Errors are signaled by raising an exception. Note that the value_type of the span is not necessarily T; an example is bool for which we return a span of char.

getDataSpan() [2/3]

template<class T>

const_span< T > SG::AuxVectorBase::getDataSpan

(

const std::string &

name

)

const

Return a span over an aux data item.

Parameters

auxid

The desired aux data item.

This will return a span containing the value of the requested auxiliary variable for all elements in the container. If the item doesn't exist, it will be created. Errors are signaled by raising an exception. Note that the value_type of the span is not necessarily T; an example is bool for which we return a span of char.

getDataSpan() [3/3]

const AuxDataSpanBase * SG::AuxVectorData::getDataSpan ( SG::auxid_t auxid ) const

inherited

Return a reference to a description of this vector's start+size.

Parameters

auxid

The desired aux data item.

This low-overhead method of getting the start+size of an auxiliary variable. The returned object will be updated if the variable's vector changes. Raises an exception if the variable does not exist.

This is in principle a const-correctness violation, since AuxDataSpanBase has a non-const pointer to the start of the vector. But doing it properly is kind of painful, and as this interface is only meant to be used internally, it's likely not a real problem.

getDataSpanOol()

const AuxDataSpanBase * SG::AuxVectorData::getDataSpanOol ( SG::auxid_t auxid, bool allowMissing ) const

privateinherited

Return a reference to a description of this vector's start+size, out-of-line portion.

Parameters

auxid	The desired aux data item.
allowMissing	If true, then return nullptr if the variable is missing rather than throwing an exception.

When this function returns, the cache entry m_spanCache[auxid] will be valid. That entry is also returned. If there's an error, the function will throw an exception rather than returning.

Definition at line 456 of file AuxVectorData.cxx.

{
  guard_t guard (m_mutex);
 
  // Fetch the pointer from the store, or raise an exception if we don't
  // have a const store.
  const IAuxTypeVector* v = 0;
  const SG::IConstAuxStore* store = getConstStore();
  if (store)
    v = store->getVector (auxid);
  else
    throw SG::ExcNoAuxStore (auxid);
 
  // Check that we got a good pointer back, otherwise throw.
  const AuxDataSpanBase* ptr = nullptr;
  if (v) {
    ptr = &v->getDataSpan();
    // We could avoid the const_cast here by having distinct const and
    // non-const Cache types, holding const void* and void*, respectively.
    // However, since this is a purely internal class that users don't
    // deal with directly, that's not worth the bother (and the extra code).
    AuxDataSpanBase* vp ATLAS_THREAD_SAFE = const_cast<AuxDataSpanBase*> (ptr);
    m_spanCache.store (auxid, vp);
  }
  else if (!allowMissing)
    throw SG::ExcBadAuxVar (auxid);
 
  return ptr;
}

getDecoration()

template<class T>

AuxDataTraits< T >::reference_type SG::AuxVectorData::getDecoration ( SG::auxid_t auxid, size_t ndx ) const

inherited

Return reference to an aux decoration item.

Parameters

auxid	The desired aux decoration item.
ndx	Index of the element to return.

This will return a reference to element ndx of aux decoration item auxid. If the aux data item does not exist, it will be created. Errors are signaled by raising an exception.

Warning: no type checking is done. You should usually access the data via Decorator.

The difference between getDecoration and getData is that getDecoration takes a const container as input, but returns a non-const reference. This will only succeed if either the container is not locked or the item was first accessed as a decoration.

getDecorationArray()

void * SG::AuxVectorData::getDecorationArray ( SG::auxid_t auxid ) const

inherited

Return a pointer to the start of an aux data vector for a decoration.

Parameters

auxid

The desired aux data item.

This will return a pointer to the start of the data for aux data item auxid. If the item doesn't exist, it will be created. Errors are signaled by raising an exception.

The difference between getDecorationArray and getDataArray is that getDecorationArray takes a const container as input, but returns a non-const pointer. This will only succeed if either the container is not locked or the item was first accessed as a decoration.

getDecorationOol()

void * SG::AuxVectorData::getDecorationOol ( SG::auxid_t auxid ) const

privateinherited

Out-of-line portion of data access (decorator version).

Parameters

auxid

aux data item being accessed.

When this function returns, the cache entry m_cache[auxid] will be valid. That entry is also returned. If there's an error, the function will throw an exception rather than returning.

The difference between getDecorationOol and getDataOol is that getDecorationOol takes a const container as input, but returns a non-const pointer. This will only succeed if either the container is not locked or the item was first accessed as a decoration.

Definition at line 397 of file AuxVectorData.cxx.

{
  guard_t guard (m_mutex);
 
  // Fetch the pointer from the store, or raise an exception if we don't
  // have a non-const store.
  void* ptr = 0;
  if (m_store) {
    // Avoid warning about calling non-const function.  OK here.
    IAuxStore* store ATLAS_THREAD_SAFE = m_store;
    if (SG::AuxTypeRegistry::instance().isLinked (auxid)) {
      ptr = store->getDecoration (auxid, 0, 0);
    }
    else {
      ptr = store->getDecoration (auxid, this->size_v(), this->capacity_v());
    }
  }
  else if (getConstStore()) {
    // The whole point of decorations is to allow adding information to
    // something that's otherwise const.  So we have the const_cast here.
    // The store object is responsible for determining whether the
    // modification is really allowed or not.
    IConstAuxStore* store ATLAS_THREAD_SAFE =
       const_cast<IConstAuxStore*> (getConstStore());
    if (SG::AuxTypeRegistry::instance().isLinked (auxid)) {
      ptr = store->getDecoration (auxid, 0, 0);
    }
    else {
      ptr = store->getDecoration (auxid, this->size_v(), this->capacity_v());
    }
  }
  else
    throw SG::ExcNoAuxStore (auxid);
 
  // Check that we got a good pointer back, otherwise throw.
  if (!ptr)
    throw SG::ExcBadAuxVar (auxid);
 
  m_decorCache.store (auxid, ptr);
 
  // Set the same entry in the const cache as well.
  m_constCache.store (auxid, ptr);
 
  return ptr;
}

getDecorationSpan()

template<class T>

span< T > SG::AuxVectorBase::getDecorationSpan

(

const std::string &

name

)

const

Return a span over an aux data item for a decoration.

Parameters

auxid

The desired aux data item.

This will return a span containing the value of the requested auxiliary variable for all elements in the container. If the item doesn't exist, it will be created. Errors are signaled by raising an exception. Note that the value_type of the span is not necessarily T; an example is bool for which we return a span of char.

The difference between getDecorationSpan and getDataSpan is that getDecorationSpan takes a const container as input, but returns a span over non-const objects. This will only succeed if either the container is not locked or the item was first accessed as a decoration.

getDecorIDs()

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

inherited

Return a set of identifiers for decorations for this object.

Definition at line 215 of file AuxVectorData.cxx.

{
  if (getConstStore())
    return getConstStore()->getDecorIDs();
  return s_emptySet;
}

getStore() [1/2]

SG::IAuxStore * SG::AuxVectorData::getStore ( )

inherited

Return the current store, as a non-const interface.

This will be non-zero if a non-const store is associated with this object.

getStore() [2/2]

const SG::IAuxStore * SG::AuxVectorData::getStore ( ) const

inherited

Return the current store, as a non-const interface.

This will be non-zero if a non-const store is associated with this object.

getWritableAuxIDs()

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

inherited

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

This will include only non-const identifiers. If no store is associated with this object, this will return an empty set.

Definition at line 231 of file AuxVectorData.cxx.

{
  if (m_store)
    return m_store->getWritableAuxIDs();
  return s_emptySet;
}

hasNonConstStore()

bool SG::AuxVectorData::hasNonConstStore ( ) const

inherited

Return true if this object has an associated non-const store.

hasStore()

bool SG::AuxVectorData::hasStore ( ) const

inherited

Return true if this object has an associated store.

initAuxVectorBase()

template<class DVL>

void SG::AuxVectorBase::initAuxVectorBase ( SG::OwnershipPolicy ownPolicy, SG::IndexTrackingPolicy indexTrackingPolicy )

protected

Initialize index tracking mode.

Parameters

ownPolicy	The container ownership policy.
indexTrackingPolicy	The requested index tracking policy.

DVL should be the most-derived class for this container.

This handles the logic for setting the state of index tracking. If this container does not handle aux data, then index tracking is always off. Otherwise, it depends on the requested policies. In any case, it is an error to turn off index tracking for a container that has an associated aux store.

initAuxVectorBase1() [1/2]

void SG::AuxVectorBase::initAuxVectorBase1 ( const std::false_type & , SG::OwnershipPolicy , SG::IndexTrackingPolicy  )

private

Initialize index tracking mode — no-auxdata specialization.

Parameters

ownPolicy	The container ownership policy.
indexTrackingPolicy	The requested index tracking policy.

Since this is the no-auxdata case, it always sets index tracking to false. An exception is raised if the container has an associated store (but that should never actually happen).

Definition at line 130 of file AuxVectorBase.cxx.

{
  m_trackIndices = false;
  if (this->hasStore())
    throw SG::ExcUntrackedSetStore();
}

initAuxVectorBase1() [2/2]

void SG::AuxVectorBase::initAuxVectorBase1 ( const std::true_type & , SG::OwnershipPolicy ownPolicy, SG::IndexTrackingPolicy indexTrackingPolicy )

private

Initialize index tracking mode — auxdata specialization.

Parameters

ownPolicy	The container ownership policy.
indexTrackingPolicy	The requested index tracking policy.

Sets index tracking based on the requested policies. An exception is raised if index tracking is disabled and the container has an associated store.

Definition at line 150 of file AuxVectorBase.cxx.

{
  if (indexTrackingPolicy == SG::ALWAYS_TRACK_INDICES)
    m_trackIndices = true;
  else if (indexTrackingPolicy == SG::NEVER_TRACK_INDICES)
    m_trackIndices = false;
  else if (ownPolicy == SG::OWN_ELEMENTS)
    m_trackIndices = true;
  else
    m_trackIndices = false;
 
  if (!m_trackIndices && this->hasStore())
    throw SG::ExcUntrackedSetStore();
}

isAvailable() [1/2]

bool SG::AuxVectorData::isAvailable

(

auxid_t

id

)

const

Test to see if a variable exists in the store.

Parameters

id	The variable to test.

isAvailable() [2/2]

template<class T>

bool SG::AuxVectorBase::isAvailable	(	const std::string &	name,
		const std::string &	clsname = "" ) const

Test to see if a variable exists in the store.

Parameters

name	Name of the aux variable.
clsname	The name of the associated class. May be blank.

isAvailableOol()

bool SG::AuxVectorData::isAvailableOol ( auxid_t id ) const

privateinherited

Out-of-line portion of isAvailable.

Parameters

id	The variable to test.

Definition at line 243 of file AuxVectorData.cxx.

{
  guard_t guard (m_mutex);
 
  const SG::IConstAuxStore* store = getConstStore();
  if (!store) return false;
 
  // Don't rely on getAuxIDs() --- the store can lie.
  // Explicitly try to fetch the data.
  const void* ptr = store->getData (id);
  if (ptr) {
    // We could avoid the const_cast here by having distinct const and
    // non-const Cache types, holding const void* and void*, respectively.
    // However, since this is a purely internal class that users don't
    // deal with directly, that's not worth the bother (and the extra code).
    void* vp ATLAS_THREAD_SAFE = const_cast<void*> (ptr);
    m_constCache.store (id, vp);
    return true;
  }
  return false;
}

isAvailableWritable() [1/2]

bool SG::AuxVectorData::isAvailableWritable

(

auxid_t

id

)

Test to see if a variable is available for writing.

Parameters

id	The variable to test.

isAvailableWritable() [2/2]

template<class T>

bool SG::AuxVectorBase::isAvailableWritable	(	const std::string &	name,
		const std::string &	clsname = "" )

Test to see if a variable is available for writing.

Parameters

name	Name of the aux variable.
clsname	The name of the associated class. May be blank.

isAvailableWritableAsDecoration() [1/2]

bool SG::AuxVectorData::isAvailableWritableAsDecoration

(

auxid_t

id

)

const

Test to see if a variable is available for writing as a decoration.

Parameters

id	The variable to test.

isAvailableWritableAsDecoration() [2/2]

template<class T>

bool SG::AuxVectorBase::isAvailableWritableAsDecoration	(	const std::string &	name,
		const std::string &	clsname = "" ) const

Test to see if a variable is available for writing as a decoration.

Parameters

name	Name of the aux variable.
clsname	The name of the associated class. May be blank.

isAvailableWritableAsDecorationOol()

bool SG::AuxVectorData::isAvailableWritableAsDecorationOol ( auxid_t id ) const

privateinherited

Out-of-line portion of isAvailableWritableAsDecoration.

Parameters

id	The variable to test.

Definition at line 282 of file AuxVectorData.cxx.

{
  if (!isAvailableOol (id)) return false;
 
  // Not nice, but not sure we can do otherwise without changing interfaces.
  // I think the case of a caught exception should be rare.
  try {
    this->getDecorationArray (id);
  }
  catch (const SG::ExcStoreLocked&) {
    return false;
  }
  return true;
}

isAvailableWritableOol()

bool SG::AuxVectorData::isAvailableWritableOol ( auxid_t id )

privateinherited

Out-of-line portion of isAvailableWritable.

Parameters

id	The variable to test.

Definition at line 270 of file AuxVectorData.cxx.

{
  const SG::IAuxStore* store = getStore();
  if (!store) return false;
  return store->getWritableAuxIDs().test(id);
}

lock()

void SG::AuxVectorData::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 ILockable.

Definition at line 633 of file AuxVectorData.cxx.

{
  if (m_store) {
    m_store->lock();
    clearCache();
  }
 
  // No error if no store or no writable store.
}

lockDecoration()

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

inherited

Explicitly lock a decoration.

Parameters

auxid

ID of the decoration to lock.

This is only safe if no other thread can be accessing this decoration. It is strongly preferred to do this via a WriteDecorHandle, where the dependencies can help ensure this.

Definition at line 687 of file AuxVectorData.cxx.

{
  const IConstAuxStore* store = this->getConstStore();
  if (store) {
    // Casting away const ok if no other thread is accessing this decoration.
    IConstAuxStore* store_nc ATLAS_THREAD_SAFE = const_cast<IConstAuxStore*> (store);
    store_nc->lockDecoration (auxid);
    this->clearDecorCache (auxid);
  }
}

moveAux() [1/3]

void SG::AuxVectorBase::moveAux ( size_t index, const void * p, bool clear = false, bool skipDestClear = false )

protected

Set index on an element and copy auxiliary data.

Parameters

index	Container index at which the new element is being added.
p	The new element being added.
clear	If true, then any auxiliary data initially associated with p are cleared after being copied.
skipDestClear	Normally, if p does not have auxiliary data, then the variables of the destination are cleared. If this flag is true, then this clear is skipped. This can be appropriate as part of a push_back, where the destination is already known to be clear.

Overload for the no-auxdata case.

moveAux() [2/3]

template<class ForwardIterator>

void SG::AuxVectorBase::moveAux ( size_t index, ForwardIterator beg, ForwardIterator end, bool clear = false, bool skipDestClear = false )

protected

Set index on a range of elements and copy auxiliary data.

Parameters

index	Container index at which the first new element is being added.
beg	The start of the range of new elements.
end	The end of the range of new elements.
clear	If true, then any auxiliary data initially associated with the elements are cleared after being copied.
skipDestClear	Normally, if the elements do not have auxiliary data, then the variables of the destination are cleared. If this flag is true, then this clear is skipped. This can be appropriate as part of a push_back, where the destination is already known to be clear.

The elements in the range are being a added to the container at index. If the new elements have associated auxiliary data, copy it to the container starting at index. Then set the container / index on the elements in the range.

ForwardIterator should be an iterator over the DataVector (not a base iterator).

moveAux() [3/3]

void SG::AuxVectorBase::moveAux ( size_t index, SG::AuxElement * p, bool clear = false, bool skipDestClear = false )

protected

Set index on an element and copy auxiliary data.

Parameters

index	Container index at which the new element is being added.
p	The new element being added.
clear	If true, then any auxiliary data initially associated with p are cleared after being copied.
skipDestClear	Normally, if p does not have auxiliary data, then the variables of the destination are cleared. If this flag is true, then this clear is skipped. This can be appropriate as part of a push_back, where the destination is already known to be clear.

Element p is being added to the container at index. If p has associated auxiliary data, copy it to the container at index. Then set the container / index on p.

Definition at line 221 of file AuxVectorBase.cxx.

{
  if (!m_trackIndices)
    return;
 
  SG::AuxElement to (this, index);
  if (!p) {
    if (!skipDestClear) {
      AuxElement::clearAuxHelper (*this, index);
    }
    return;
  }
 
  if (p->hasStore() || !skipDestClear) {
    AuxElement::copyAuxHelper (*this, index, *p, false);
  }
  if (clear)
    p->clearAux();
  p->setIndex (index, this);
}

moveAux1() [1/2]

template<class ForwardIterator>

void SG::AuxVectorBase::moveAux1 ( const std::false_type & , size_t index, ForwardIterator beg, ForwardIterator end, bool clear = false, bool skipDestClear = false )

private

Set index on a range of elements and copy auxiliary data.

Parameters

index	Container index at which the first new element is being added.
beg	The start of the range of new elements.
end	The end of the range of new elements.
clear	If true, then any auxiliary data initially associated with the elements are cleared after being copied.
skipDestClear	Normally, if the elements do not have auxiliary data, then the variables of the destination are cleared. If this flag is true, then this clear is skipped. This can be appropriate as part of a push_back, where the destination is already known to be clear.

No-auxdata version; a no-op except for checking m_trackIndices.

moveAux1() [2/2]

template<class ForwardIterator>

void SG::AuxVectorBase::moveAux1 ( const std::true_type & , size_t index, ForwardIterator beg, ForwardIterator end, bool clear = false, bool skipDestClear = false )

private

Set index on a range of elements and copy auxiliary data.

Parameters

index	Container index at which the first new element is being added.
beg	The start of the range of new elements.
end	The end of the range of new elements.
clear	If true, then any auxiliary data initially associated with the elements are cleared after being copied.
skipDestClear	Normally, if the elements do not have auxiliary data, then the variables of the destination are cleared. If this flag is true, then this clear is skipped. This can be appropriate as part of a push_back, where the destination is already known to be clear.

The elements in the range are being a added to the container at index. If the new elements have associated auxiliary data, copy it to the container starting at index. Then set the container / index on the elements in the range.

The auxdata case.

operator=()

AuxVectorBase & SG::AuxVectorBase::operator=

(

AuxVectorBase &&

rhs

)

Move assignment.

Parameters

rhs	The container from which to move.

Definition at line 48 of file AuxVectorBase.cxx.

{
  if (this != &rhs) {
    AuxVectorData::operator= (std::move (rhs));
    m_trackIndices = rhs.m_trackIndices;
  }
  return *this;
}

reserve()

template<class DVL>

void SG::AuxVectorBase::reserve ( size_t size )

protected

Change the capacity of the aux data associated with this container.

Parameters

size	The new container size.

DVL should be the most-derived class for this container.

reserve1() [1/2]

void SG::AuxVectorBase::reserve1 ( const std::false_type & , size_t size )

private

Change the capacity of the aux data associated with this container.

Parameters

size	The new container size.

The no-auxdata case; a no-op except for checking m_trackIndices.

reserve1() [2/2]

void SG::AuxVectorBase::reserve1 ( const std::true_type & , size_t size )

private

Change the capacity of the aux data associated with this container.

Parameters

size	The new container size.

The auxdata case.

Definition at line 193 of file AuxVectorBase.cxx.

{
  if (this->hasNonConstStore()) {
    this->getStore()->reserve (size);
    clearCache();
  }
  else if (this->hasStore())
    throw SG::ExcConstAuxData ("reserve");
}

resize()

template<class DVL>

void SG::AuxVectorBase::resize ( size_t size )

protected

Resize the aux data associated with this container.

Parameters

size	The new container size.

DVL should be the most-derived class for this container.

resize1() [1/2]

void SG::AuxVectorBase::resize1 ( const std::false_type & , size_t size )

private

Resize the aux data associated with this container.

Parameters

size	The new container size.

The no-auxdata case; a no-op except for checking m_trackIndices.

resize1() [2/2]

void SG::AuxVectorBase::resize1 ( const std::true_type & , size_t size )

private

Resize the aux data associated with this container.

Parameters

size	The new container size.

The auxdata case.

Definition at line 174 of file AuxVectorBase.cxx.

{
  if (this->hasNonConstStore()) {
    if (!this->getStore()->resize (size)) {
      // Only clear the cache if iterators have been invalidated.
      clearCache();
    }
  }
  else if (this->hasStore())
    throw SG::ExcConstAuxData ("resize");
}

resortAux()

template<class ForwardIterator>

void SG::AuxVectorBase::resortAux ( size_t index, ForwardIterator beg, ForwardIterator end )

protected

Reset indices / reorder aux data after elements have been permuted.

Parameters

index	Index in the container of the start of the range.
beg	Start of the range of elements to process.
end	End of the range of elements to process.

Call this after some operation that has permuted the elements in the container (such as sort). The index information in the elements will be used to permute all auxiliary data in the same way. Finally, all the indices will be reset in the correct order.

ForwardIterator should be an iterator over the DataVector (not a base iterator).

resortAux1() [1/2]

template<class ForwardIterator>

void SG::AuxVectorBase::resortAux1 ( const std::false_type & , size_t index, ForwardIterator beg, ForwardIterator end )

private

Reset indices / reorder aux data after elements have been permuted.

Parameters

index	Index in the container of the start of the range.
beg	Start of the range of elements to process.
end	End of the range of elements to process.

No-auxdata version; a no-op except for checking m_trackIndices.

resortAux1() [2/2]

template<class ForwardIterator>

void SG::AuxVectorBase::resortAux1 ( const std::true_type & , size_t index, ForwardIterator a, ForwardIterator b )

private

Reset indices / reorder aux data after elements have been permuted.

Parameters

index	Index in the container of the start of the range.
beg	Start of the range of elements to process.
end	End of the range of elements to process.

Call this after some operation that has permuted the elements in the container (such as sort). The index information in the elements will be used to permute all auxiliary data in the same way. Finally, all the indices will be reset in the correct order.

The auxdata case.

setCache() [1/2]

void SG::AuxVectorData::setCache ( SG::auxid_t auxid, const void * ptr )

protectedinherited

Explicitly set a cache pointer.

Parameters

auxid	Variable ID to set.
ptr	Pointer to which the cache entry should be set.

For internal use; do not use from user code. This does not acquire the lock — it's mostly meant to be used from a constructor.

setCache() [2/2]

void SG::AuxVectorData::setCache ( SG::auxid_t auxid, void * ptr )

protectedinherited

Explicitly set a cache pointer.

Parameters

auxid	Variable ID to set.
ptr	Pointer to which the cache entry should be set.

For internal use; do not use from user code. This does not acquire the lock — it's mostly meant to be used from a constructor.

setConstStore()

void SG::AuxVectorBase::setConstStore

(

const SG::IConstAuxStore *

store

)

Synonym for setStore with IConstAuxStore.

Parameters

store

The new store.

setIndexForResort()

void SG::AuxVectorBase::setIndexForResort ( SG::AuxElement * elt, size_t idx )

private

setIndices()

template<class ForwardIterator>

void SG::AuxVectorBase::setIndices ( ForwardIterator beg, ForwardIterator end, size_t first = 0 )

protected

Set container/index for all elements within a range.

Parameters

beg	Beginning of the range.
end	End of the range.
first	Index to set for the first element in the range.

For all elements in the range, the container will be set to this container, and indices will be set sequentially, starting with first.

ForwardIterator should be an iterator over the DataVector (not a base iterator).

setIndices1() [1/2]

template<class ForwardIterator>

void SG::AuxVectorBase::setIndices1 ( const std::false_type & , ForwardIterator beg, ForwardIterator end, size_t first )

private

Set container/index for all elements within a range.

Parameters

beg	Beginning of the range.
end	End of the range.
first	Index to set for the first element in the range.

This is the no-auxdata case; doesn't do anything other than checking m_trackIndices.

setIndices1() [2/2]

template<class ForwardIterator>

void SG::AuxVectorBase::setIndices1 ( const std::true_type & , ForwardIterator beg, ForwardIterator end, size_t first )

private

Set container/index for all elements within a range.

Parameters

beg	Beginning of the range.
end	End of the range.
first	Index to set for the first element in the range.

This is the auxdata case. For all elements in the range, the container will be set to this container, and indices will be set sequentially, starting with first.

setNonConstStore()

void SG::AuxVectorBase::setNonConstStore

(

SG::IAuxStore *

store

)

Synonym for setStore with IAuxStore.

Parameters

store

The new store.

setOption() [1/8]

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

inherited

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.

Definition at line 150 of file AuxVectorData.cxx.

{
  if (id == null_auxid) return false;
  SG::IAuxStore* store = getStore();
  if (!store) return false;
  return store->setOption (id, option);
}

setOption() [2/8]

template<class T>

bool SG::AuxVectorData::setOption ( auxid_t id, const std::string & optname, T arg )

inherited

Set an option for an auxiliary data variable.

Parameters

id	The variable for which we want to set the option.
optname	The name of the option to set.
arg	The option value to set.

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.

setOption() [3/8]

bool SG::AuxVectorData::setOption ( const std::string & name, const AuxDataOption & option )

inherited

Set an option for an auxiliary data variable.

Parameters

name	The name of the variable.
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.

Definition at line 168 of file AuxVectorData.cxx.

{
  auxid_t id = SG::AuxTypeRegistry::instance().findAuxID (name);
  return setOption (id, option);
}

setOption() [4/8]

bool SG::AuxVectorData::setOption ( const std::string & name, const std::string & clsname, const AuxDataOption & option )

inherited

Set an option for an auxiliary data variable.

Parameters

name	The name of the variable.
clsname	The name of the associated class. May be blank.
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.

Definition at line 186 of file AuxVectorData.cxx.

{
  auxid_t id = SG::AuxTypeRegistry::instance().findAuxID (name, clsname);
  return setOption (id, option);
}

setOption() [5/8]

template<class T>

bool SG::AuxVectorData::setOption ( const std::string & name, const std::string & clsname, const std::string & optname, T arg )

inherited

Set an option for an auxiliary data variable.

Parameters

name	The name of the variable.
clsname	The name of the associated class. May be blank.
optname	The name of the option to set.
arg	The option value to set.

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.

setOption() [6/8]

bool SG::AuxVectorData::setOption ( const std::string & name, const std::string & optname, double arg )

inherited

setOption() [7/8]

bool SG::AuxVectorData::setOption ( const std::string & name, const std::string & optname, float arg )

inherited

setOption() [8/8]

bool SG::AuxVectorData::setOption ( const std::string & name, const std::string & optname, int arg )

inherited

Set an option for an auxiliary data variable.

Parameters

name	The name of the variable.
optname	The name of the option to set.
arg	The option value to set.

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.

setStore() [1/3]

void SG::AuxVectorBase::setStore

(

const DataLink< SG::IConstAuxStore > &

store

)

Set the store associated with this object.

Parameters

store

The new store.

This will clear the non-const store pointer, and also clear the cache.

It is an error to set a store for a container for which index tracking is disabled. That will raise an ExcUntrackedSetStore exception.

Definition at line 112 of file AuxVectorBase.cxx.

{
  if (!m_trackIndices)
    throw SG::ExcUntrackedSetStore();
  SG::AuxVectorData::setStore (store);
}

setStore() [2/3]

void SG::AuxVectorBase::setStore

(

const SG::IConstAuxStore *

store

)

Set the store associated with this object.

Parameters

store

The new store.

This will clear the non-const store pointer, and also clear the cache.

It is an error to set a store for a container for which index tracking is disabled. That will raise an ExcUntrackedSetStore exception.

Definition at line 76 of file AuxVectorBase.cxx.

{
  if (store && !m_trackIndices)
    throw SG::ExcUntrackedSetStore();
  SG::AuxVectorData::setStore (store);
}

setStore() [3/3]

void SG::AuxVectorBase::setStore

(

SG::IAuxStore *

store

)

Set the store associated with this object.

Parameters

store

The new store.

This will set both the const and non-const store pointers, and also clear the cache.

It is an error to set a store for a container for which index tracking is disabled. That will raise an ExcUntrackedSetStore exception.

nb. List the non-const overload before the const one; otherwise, we can't call the const one from python.

Parameters

store

The new store.

This will set both the const and non-const store pointers, and also clear the cache.

It is an error to set a store for a container for which index tracking is disabled. That will raise an ExcUntrackedSetStore exception.

Definition at line 94 of file AuxVectorBase.cxx.

{
  if (store && !m_trackIndices)
    throw SG::ExcUntrackedSetStore();
  SG::AuxVectorData::setStore (store);
}

shift()

template<class DVL>

void SG::AuxVectorBase::shift ( DVL & cont, size_t pos, ptrdiff_t offs )

protected

Shift the elements of the container.

Parameters

cont	The container that's being shifted.
pos	The starting index for the shift.
offs	The (signed) amount of the shift.

The container should be the derived container. The elements in the container should have already been shifted; this operation will then adjust the element indices and also shift the elements in the vectors for all aux data items. 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).

shift1() [1/2]

template<class DVL>

void SG::AuxVectorBase::shift1 ( const std::false_type & , DVL & cont, size_t pos, ptrdiff_t offs )

private

Shift the elements of the container.

Parameters

cont	The container that's being shifted.
pos	The starting index for the shift.
offs	The (signed) amount of the shift.

No-auxdata version; a no-op except for checking m_trackIndices.

shift1() [2/2]

template<class DVL>

void SG::AuxVectorBase::shift1 ( const std::true_type & , DVL & cont, size_t pos, ptrdiff_t offs )

private

Shift the elements of the container.

Parameters

cont	The container that's being shifted.
pos	The starting index for the shift.
offs	The (signed) amount of the shift.

Auxdata version.

The container should be the derived container. The elements in the container should have already been shifted; this operation will then adjust the element indices and also shift the elements in the vectors for all aux data items. 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).

size_v()

virtual size_t SG::AuxVectorData::size_v ( ) const

pure virtualinherited

Return the size of the container.

This is used when we need to create a new aux data vector.

Implemented in SG::AuxElementData, and SG::AuxVectorInterface.

swap() [1/2]

void SG::AuxVectorBase::swap ( AuxVectorBase & other )

protected

Swap with another container.

Parameters

other

The container with which to swap.

swap() [2/2]

void SG::AuxVectorData::swap ( AuxVectorData & other )

inherited

Swap this instance with another.

Parameters

other

The other instance with which to swap.

swapElementsAux() [1/2]

void SG::AuxVectorBase::swapElementsAux ( size_t aindex, size_t bindex, const void * a, const void * b, AuxVectorBase * bcont )

protected

Swap indices and auxiliary data between two elements.

Parameters

aindex	Index of the first element, in this container.
bindex	Index of the second element, in bcont.
a	Pointer to the first element.
b	Pointer to the second element.
bcont	Container holding the second element. (May be the same as this, but doesn't have to be.)

This is the no-auxdata case; it is a no-op except for checking m_trackIndices.

swapElementsAux() [2/2]

void SG::AuxVectorBase::swapElementsAux ( size_t aindex, size_t bindex, SG::AuxElement * a, SG::AuxElement * b, AuxVectorBase * bcont )

protected

Swap indices and auxiliary data between two elements.

Parameters

aindex	Index of the first element, in this container.
bindex	Index of the second element, in bcont.
a	Pointer to the first element.
b	Pointer to the second element.
bcont	Container holding the second element. (May be the same as this, but doesn't have to be.)

Elements a at aindex in this and b at bindex in bcont are being swapped. Swap the index / container references between the elements and also swap the auxiliary data if it exists.

Definition at line 258 of file AuxVectorBase.cxx.

{
  AuxVectorBase* acont = this;
 
  // If one of the elements is null, then this is just a @c moveAux.
  if (!b) {
    if (!a) return;
    acont->moveAux (aindex, a, true);
    return;
  }
  if (!a) {
    bcont->moveAux (bindex, b, true);
    return;
  }
 
  // Reset indices.
  if (b && bcont->trackIndices())
    b->setIndex (bindex, bcont);
  if (a && acont->trackIndices())
    a->setIndex (aindex, acont);
 
  // Check stores.
  if (!this->hasNonConstStore()) {
    if (this->hasStore()) {
      throw SG::ExcConstAuxData ("swapElementsAux");
    }
    return;
  }
 
  // Swap aux data.
 
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  SG::auxid_set_t a_ids = acont->getAuxIDs();
  for (SG::auxid_t auxid : a_ids) {
    r.swap (auxid, *acont, aindex, *bcont, bindex, 1);
  }
  for (SG::auxid_t auxid : bcont->getAuxIDs()) {
    if (!a_ids.test (auxid)) {
      r.swap (auxid, *acont, aindex, *bcont, bindex, 1);
    }
  }
}

trackIndices()

bool SG::AuxVectorBase::trackIndices

(

)

const

Return true if index tracking is enabled for this container.

Friends And Related Symbol Documentation

ResortAuxHelper

friend class ResortAuxHelper

friend

Definition at line 862 of file AuxVectorBase.h.

Member Data Documentation

ATLAS_THREAD_SAFE [1/5]

size_t s_minCacheLen SG::AuxVectorData::ATLAS_THREAD_SAFE

staticprotectedinherited

Minimum length to use for the cache vector.

Only changed by unit tests.

Definition at line 589 of file AuxVectorData.h.

ATLAS_THREAD_SAFE [2/5]

Cache m_cache SG::AuxVectorData::ATLAS_THREAD_SAFE

mutableprivateinherited

Cached pointers to the start of aux data vectors, non-const.

Definition at line 960 of file AuxVectorData.h.

ATLAS_THREAD_SAFE [3/5]

Cache m_constCache SG::AuxVectorData::ATLAS_THREAD_SAFE

mutableprivateinherited

Cached pointers to the start of aux data vectors, const.

Definition at line 963 of file AuxVectorData.h.

ATLAS_THREAD_SAFE [4/5]

Cache m_decorCache SG::AuxVectorData::ATLAS_THREAD_SAFE

mutableprivateinherited

Cached pointers to the start of aux data vectors, decorations.

Definition at line 966 of file AuxVectorData.h.

ATLAS_THREAD_SAFE [5/5]

Cache m_spanCache SG::AuxVectorData::ATLAS_THREAD_SAFE

mutableprivateinherited

Cached pointers to span descriptors.

Definition at line 969 of file AuxVectorData.h.

m_constStore

const SG::IConstAuxStore* SG::AuxVectorData::m_constStore

privateinherited

Associated store, const.

Definition at line 977 of file AuxVectorData.h.

m_constStoreLink

DataLink< SG::IConstAuxStore > SG::AuxVectorData::m_constStoreLink

privateinherited

Associated store link, const.

Definition at line 981 of file AuxVectorData.h.

m_mutex

mutex_t SG::AuxVectorData::m_mutex

mutableprivateinherited

Definition at line 987 of file AuxVectorData.h.

m_store

SG::IAuxStore* SG::AuxVectorData::m_store

privateinherited

Associated store, non-const.

Definition at line 973 of file AuxVectorData.h.

m_trackIndices

bool SG::AuxVectorBase::m_trackIndices

private

Flag if index tracking is enabled.

Definition at line 866 of file AuxVectorBase.h.

s_emptySet

const SG::auxid_set_t SG::AuxVectorData::s_emptySet

staticprivateinherited

Empty auxid set, used for a return value when we have no associated store.

Definition at line 990 of file AuxVectorData.h.

supportsThinning

bool SG::AuxVectorBase::supportsThinning = true

staticconstexpr

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 315 of file AuxVectorBase.h.

---

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

• AuxVectorBase.h
• AuxVectorBase.cxx