SG Namespace Reference

Forward declaration. More...

Namespaces
namespace	ArenaBlockAlignDetail
namespace	detail
namespace	JaggedVecVectorFactoryFuncs
namespace	CondHandleDefault

Classes
struct	DataBucketTrait< CaloConstCellContainer, U >
class	BaseInfo< CaloConstCellContainer >
class	ArenaAllocatorBase
	Common base class for arena allocator classes. More...
class	ArenaAllocatorCreator
	Provide an interface for creating an arena Allocator. More...
class	ArenaAllocatorRegistry
	Registry of allocator factories. More...
class	ArenaBase
	Part of Arena dealing with the list of allocators. More...
class	ArenaBlock
	A large memory block that gets carved into smaller uniform elements. More...
class	ArenaBlockAllocatorBase
	Common functionality for block-oriented allocators. More...
class	ArenaCachingHandle
	User interface for allocating memory that caches constructed objects. More...
class	ArenaHandle
	User interface for allocating memory. More...
class	ArenaHandleBase
	Base class for all Handle classes, containing parts that do not depend on the referenced type. More...
class	ArenaHandleBaseAllocT
	Base class for Handle classes, containing parts that depend only on the Allocator. More...
class	ArenaHandleBaseT
	Base class for Handle classes, containing parts that are independent of how the Allocator gets created. More...
class	ArenaHeader
	Proxy for a group of Arenas. More...
struct	initParams
	Heap-based allocator. More...
class	ArenaHeapSTLAllocator_initParams
	Initializer for pool allocator parameters. More...
class	ArenaHeapSTLAllocator
	STL-style allocator wrapper for ArenaHeapAllocator. More...
class	ArenaNonConstHeapSTLAllocator
	Forward declaration. More...
class	ArenaHeapSTLAllocator< T, T >
	STL-style allocator wrapper for ArenaHeapAllocator. More...
class	ArenaPoolAllocator
	Pool-based allocator. More...
class	ArenaPoolSTLAllocator_initParams
	Initializer for pool allocator parameters. More...
class	ArenaPoolSTLAllocator
	STL-style allocator wrapper for ArenaPoolAllocator. More...
class	ArenaPoolSTLAllocator< T *, VETO >
	STL-style allocator wrapper for ArenaPoolAllocator. More...
class	ArenaNonConstPoolSTLAllocator
	Forward declaration. More...
class	ArenaPoolSTLAllocator< T, typename std::enable_if<!std::is_pointer_v< T >, T >::type >
	STL-style allocator wrapper for ArenaPoolAllocator. More...
class	ArenaSharedHeapSTLAllocator
	Forward declaration. More...
class	ArenaSharedHeapSTLHeader
	Common header class for ArenaSharedHeapSTLAllocator. More...
class	DataPoolNullClear
	Null cleanup functional — does no actual cleanup. More...
class	ExcDifferentArenas
	Exception — Attempt to assign between ArenaSharedHeapSTLAllocators for different arenas. More...
class	ExcProtection
	Exception — Attempt to change memory protection failed. More...
class	ExcProtected
	Exception — Attempt to change protected arena. More...
class	LockedAllocator
	A pointer type that holds a lock on an allocator object. More...
class	ArenaAllocatorRegistryImpl
	ArenaAllocatorRegistry implementation class. More...
class	Accessor
	Helper class to provide type-safe access to aux data. More...
class	ConstAuxElement
	Const part of AuxElement. More...
class	AuxElementComplete
	Wrapper to automatically create a private store for an element. More...
class	AuxStoreConstMem
	IConstAuxStore implementation referencing external buffers. More...
class	AuxStoreStandalone
	Auxiliary data store for standalone objects. More...
class	AuxTypeRegistry
	Handle mappings between names and auxid_t. More...
class	AuxVectorBase
	Manage index tracking and synchronization of auxiliary data. More...
class	AuxVectorData
	Manage lookup of vectors of auxiliary data. More...
class	ConstAccessor
	Helper class to provide constant type-safe access to aux data. More...
class	DVLConstDataVectorBucket
	DataBucket class for ConstDataVector. More...
struct	DataBucketTrait< ConstDataVector< DV >, U >
	Metafunction to find the proper DataBucket class for the first template argument. More...
class	BaseInfo< ConstDataVector< DV > >
	Let the BaseInfo for ConstDataVector forward to that of the base DataVector. More...
struct	DataBucketTrait< DataVector< T >, U >
	Metafunction to find the proper DataBucket class for T. More...
struct	Bases< DataVector< T, DataModel_detail::NoBase > >
	Declare DataVector base class. More...
struct	TopBase< DataVector< T, DataModel_detail::NoBase > >
class	DVLDataVectorWithAllocBucket
	DataBucket class for DataVectorWithAlloc. More...
struct	DataBucketTrait< DataVectorWithAlloc< DV, ALLOC >, U >
	Metafunction to find the proper DataBucket class for the first template argument. More...
class	BaseInfo< DataVectorWithAlloc< DV, ALLOC > >
	Let the BaseInfo for DataVectorWithAlloc forward to that of the base DataVector. More...
class	ExcNoAuxStore
	Exception — Aux data requested from object with no store. More...
class	ExcBadAuxVar
	Exception — Attempt to retrieve nonexistent aux data item. More...
class	ExcConstAuxData
	Exception — Non-const operation performed on const aux data. More...
class	ExcUntrackedSetStore
	Exception — Attempt to set aux data store on container that doesn't track indices, or disable index tracking for a container with aux data. More...
class	ExcBadPrivateStore
	Exception — Bad use of private store. More...
class	ExcAuxTypeMismatch
	Exception — Type mismatch for aux variable. More...
class	ExcInsertionInBaseClass
	Exception — Attempted to do OP on a BASE base class of COMPLETE; can only be done on the most-derived class. More...
class	ExcStoreLocked
	Exception — Attempted to modify auxiliary data in a locked store. More...
class	ExcNonowningContainer
	Exception — Attempted to insert a unique_ptr to a non-owning container. More...
class	ExcUnknownAuxItem
	Exception — Unknown aux data item. More...
class	ExcDVToELV
	Exception — Can't convert DataVector to vector of ElementLinks. More...
class	ExcViewVectorNotView
	Exception — ViewVector not in view mode. More...
class	ExcMissingViewVectorCLID
	Exception — Missing CLID for ViewVector. More...
class	ExcMissingBaseInfo
	Exception — Missing BaseInfo. More...
class	ExcInsertMoveOwnershipMismatch
	Exception — Ownership mismatch for insertMove. More...
class	ExcFlagMismatch
	Exception — Flag mismatch for aux variable. More...
class	ExcLinkMismatch
	Exception — Linked variable mismatch. More...
class	ExcNoLinkedVar
	Exception — Linked variable not found. More...
class	ExcInvalidThinningTarget
	Exception — ThinningHandle target does not exist. More...
class	ExcBadIterSwap
	Exception — Bad iter_swap. More...
class	ExcAllocOwnership
	Exception — Bad allocation ownership. More...
class	ExcBadVarName
	Exception — Bad name for auxiliary variable. More...
class	ExcJaggedVecOverlappingCopy
	Exception — Overlapping copies not implemented for jagged vectors. More...
class	Accessor< JaggedVecElt< PAYLOAD_T >, ALLOC >
	Helper class to provide type-safe access to aux data, specialized for JaggedVecElt. More...
class	ConstAccessor< SG::JaggedVecElt< PAYLOAD_T >, ALLOC >
	Helper class to provide constant type-safe access to aux data, specialized for JaggedVecElt. More...
class	JaggedVecEltBase
	Describe one element of a jagged vector (base class). More...
class	JaggedVecElt
	Describe one element of a jagged vector. More...
class	PackedContainer
	Container to hold aux data to be stored in a packed form. More...
class	PackedConverter
	Helper for packing/unpacking a PackedContainer to/from a stream. More...
class	Accessor< PackedLink< CONT >, ALLOC >
	Helper class to provide constant type-safe access to aux data, specialized for PackedLink. More...
class	Accessor< std::vector< PackedLink< CONT >, VALLOC >, ALLOC >
	Helper class to provide constant type-safe access to aux data, specialized for a vector of PackedLink. More...
class	ConstAccessor< SG::PackedLink< CONT >, ALLOC >
	Helper class to provide constant type-safe access to aux data, specialized for PackedLink. More...
class	ConstAccessor< std::vector< SG::PackedLink< CONT >, VALLOC >, ALLOC >
	Helper class to provide constant type-safe access to aux data, specialized for a vector of PackedLink. More...
struct	PackedLinkBase
	A packed version of ElementLink. More...
struct	PackedLink
	A packed version of ElementLink. More...
class	PackedParameters
	Describe how the contents of a PackedContainer are to be saved. More...
class	ThinningDecision
	Hold thinning decisions for one container. More...
class	AtomicConstAccessor
	Access an auxiliary variable atomically. More...
class	AtomicDecorator
	Access an auxiliary variable atomically. More...
class	AuxDataTraits
	Allow customizing how aux data types are treated. More...
class	AuxDataTraits< bool, ALLOC >
	Allow customizing how aux data types are treated. More...
struct	Zero
	Helper to specialize how to make an initialized instance of T. More...
class	AuxTypeVectorHolder
	Implementation of IAuxTypeVector for specific types. More...
class	AuxTypeVectorT
	Implementation of IAuxTypeVector holding a vector instance. More...
class	AuxTypeVectorFactoryImpl
	Factory object that creates vectors using AuxTypeVector. More...
class	AuxTypeVectorFactory
	Factory object that creates vectors using AuxTypeVector. More...
class	AuxVectorInterface
	Make an AuxVectorData object from either a raw array or an aux store. More...
class	DVLDataBucket
	A DataBucket specialized for DataVector/DataList. More...
class	IsMostDerivedFlag
	Holder for the is-most-derived flag. More...
class	JaggedVecVectorHolder
	Implementation of IAuxTypeVector for JaggedVec types. More...
class	JaggedVecVectorT
	Implementation of IAuxTypeVector holding a vector of JaggedVec. More...
class	JaggedVecVectorFactory
	Factory objects that creates vectors for packed links. More...
class	AuxTypeVectorFactory< JaggedVecElt< T >, ALLOC >
	Factory object that creates vectors using AuxTypeVector. More...
class	PackedLinkVectorHolder
	Implementation of IAuxTypeVector for PackedLink types. More...
class	PackedLinkVVectorHolder
	Implementation of IAuxTypeVector for a vector of PackedLink. More...
class	PackedLinkVectorT
	Implementation of IAuxTypeVector holding a vector of PackedLink. More...
class	PackedLinkVectorFactory
	Factory object that creates vectors for packed links. More...
class	AuxTypeVectorFactory< PackedLink< CONT >, ALLOC >
	Factory object that creates vectors for packed links. More...
class	PackedLinkVVectorFactory
	Factory object that creates vectors of vectors of packed links. More...
class	AuxTypeVectorFactory< std::vector< PackedLink< CONT >, VALLOC >, ALLOC >
	Factory object that creates vectors of vectors of packed links. More...
class	TypelessConstAccessor
	Helper class to provide const generic access to aux data. More...
struct	Bases< ViewVector< DV > >
class	ViewVectorBase
	Hold the persistent representation for a ViewVector. More...
class	AuxElementData
	Internal data container. More...
class	AuxElementPrivateData
	Internal data container for private store. More...
class	AuxTypeRegistryImpl
	@Brief Implementation class for AuxTypeRegistry. More...
class	PackedContainerStreamer
	Streamer for reading/writing SG::PackedContainer instances. More...
struct	InstallPackedContainerStreamer
struct	InstallViewVectorBaseStreamer
class	AuxDataOption
	Hold information about an option setting request. More...
struct	AuxDataSpanBase
	Minimal span-like object describing the range of an auxiliary variable. More...
class	NoAuxStore
	Mark that there's no associated AuxStore class. More...
struct	AuxStore_traits_AuxDefault
	Default traits values for aux data case. More...
struct	AuxStore_traits_NoAuxDefault
	Default traits values for no-aux data case. More...
struct	AuxStore_traits1
	Helper for the case where DOBJ::base_value_type does not derive from SG::IAuxElement. More...
struct	AuxStore_traits1< DOBJ, typename std::is_base_of< IAuxElement, typename DOBJ::base_value_type >::type >
	Helper for the case where DOBJ::base_value_type does derive from SG::IAuxElement. More...
struct	AuxStore_traits
	Associate AuxStore classes with EDM container classes (default implementation). More...
struct	AuxStore_traits< DOBJ * >
	Associate AuxStore classes with EDM container classes. More...
class	AuxTypePlaceholder
	Used as type_info when we read an aux data item but it doesn't exist in the registry. More...
class	auxid_set_t
	A set of aux data identifiers. More...
class	IAuxSetOption
	Abstract interface for setting a option on a aux data container. More...
class	IAuxStore
	Interface for non-const operations on an auxiliary store. More...
class	IAuxStoreHolder
	Interface for objects taking part in direct ROOT I/O. More...
class	IAuxStoreIO
	Interface providing I/O for a generic auxiliary store. More...
class	IAuxTypeVector
	Abstract interface for manipulating vectors of arbitrary types. More...
class	IAuxTypeVectorFactory
	Interface for factory objects that create vectors. More...
class	ToTransient
	Define a hook for running code after an object has been read. More...
class	RootAuxVector
	Dynamic implementation of IAuxTypeVector, relying on root vector proxy. More...
class	RootAuxVectorFactory
	Dynamic implementation of IAuxVectorFactory, relying on root's vector proxy. More...
class	VarHandleType
class	VarHandleKeyType
class	VarHandleKeyArrayType
class	NotHandleType
struct	HandleClassifier
	Helper to classify the type of a handle property. More...
struct	IsThreadSafeForUH< int, std::true_type >
struct	BaseType
	Helper metafunction to get base class types. More...
class	BaseInfoImpl
class	CopyConversionBase
	Base class for copy conversions. More...
class	CopyConversion
	Base class for copy conversions, templated on source and destination classes. More...
struct	RegisterAddBaseInit
struct	RegisterAddCopyConversionInit
class	BaseInfoBase
	The non-template portion of the BaseInfo implementation. More...
class	BaseInfo
	Provide an interface for finding inheritance information at run time. More...
struct	Bases< CondCont< T > >
struct	Bases< CondContMixed< T > >
class	DataBucket
struct	DataBucketTrait
	Metafunction to find the proper DataBucket class for T. More...
class	IRegisterTransient
	Interface for registering a transient object in t2p map. More...
class	ReadMetaHandle
struct	DataBucketTrait< MetaCont< T >, U >
	Metafunction to find the proper DataBucket class for T. More...
class	MetaContDataBucket
	Allow converting MetaCont<T> to T. More...
class	SlotSpecificObj
	Maintain a set of objects, one per slot. More...
class	ThinningCache
	Cache thinning decisions for converters. More...
class	ThinningDecisionBase
	Hold thinning decisions for one container. More...
class	ThinningInfo
	Hold thinning/slimming information for a given object. More...
struct	TopBase
	Calculate topmost base accessible via SG_BASES that also has a defined CLID. More...
struct	TopBase< SG::NoBase >
struct	BaseInfoBaseImpl
class	GenericElementLinkBase
	Generic base class for ElementLinks. More...
class	ExcPointerNotInSG
	Exception — The object referenced by a DataLink / ElementLink is not registered in SG. More...
class	ExcCLIDMismatch
	Exception — Attempt to set DataLink / ElementLink with CLID <clid> to object with CLID <clid>. More...
class	ExcInvalidLink
	Exception — Attempt to dereference invalid DataLink / ElementLink ". More...
class	ExcBadForwardLink
	Exception — ForwardIndexingPolicy: internal link state is invalid. More...
class	ExcElementNotFound
	Exception — element not found. More...
class	ExcInvalidIndex
	Exception — invalid index. More...
class	ExcIndexNotFound
	Exception — index not found. More...
class	ExcIncomparableEL
	Exception — incomparable ElementLink. More...
class	ExcBadToTransient
	Exception — bad toTransient. More...
class	ExcConstStorable
	Exception – Tried to retrieve const storable as a non-const pointer. More...
class	ExcBadThinning
	Exception – Bad thinning request. More...
class	DataProxyHolder
	Manage DataProxy reference in ElementLink/DataLink. More...
class	ElementLinkTraits1
	ElementLink classes for the generic case. More...
class	ElementLinkTraits1< STORABLE, BASE_VALUE_TYPE *, true >
	ElementLink classes for the case of a vector-like container of pointers. More...
class	ElementLinkTraits
	ElementLinkTraits class to specialize. More...
class	ForwardIndexingPolicy
	Indexing policy for a vector-like container. More...
struct	GenerateIndexingPolicy
class	IdentContIndexingPolicy
	Indexing policy for an IdentifiableContainer. More...
class	IndexHolder
	Store an ElementLink index for non-vector containers. More...
struct	TestSequenceTag
struct	TestSequenceTag< CONTAINER, typename CONTAINER::isSequence >
struct	IsSTLSequence
class	MapIndexingPolicy
	Indexing policy for a map-like container. More...
class	SetIndexingPolicy
	Indexing policy for a set-like container. More...
class	ELVRef
	a short ref to an ElementLink into an ElementLinkVector. More...
class	View
	A "view" of the event store (IProxyDict). More...
class	Folder
	a run-time configurable list of data objects More...
struct	SGKeyHash
	Hash functional for sgkey_t. More...
struct	SGKeyEqual
	Comparison functional for sgkey_t. More...
class	Push
	Hold a pointer to the current event store. More...
class	DataProxy
class	DataStore
	Hold DataProxy instances associated with a store. More...
class	ExcBadDataProxyCast
	Exception — Bad cast of DataProxy with CLID. More...
class	ExcProxyCollision
	Exception — Proxy collision for clid/key. More...
class	ExcSgkeyCollision
	Exception — sgkey hash collision. More...
struct	ptrhash
	Improved hash function for pointers. More...
class	FolderItem
	a Folder item (data object) is identified by the clid/key pair More...
class	IFolder
	a run-time configurable list of data objects More...
class	ObjectWithVersion
	associate a data object with its VersionedKey The object is held by a ReadHandle to delay its retrieval in case the user is interested only in the versionedKey More...
class	VersionedKey
	a StoreGateSvc key with a version number. More...
class	T2pMap
class	TransientAddress
class	StringPoolImpl
struct	RemapImpl
class	SymlinkDataObject
	Helper for symLink_impl. More...
class	CondHandleKey
class	ExcNullHandleKey
	Exception — Attempt to dereference a Read/Write/UpdateHandle with a null key. More...
class	ExcBadHandleKey
	Exception — Bad key format for VarHandleKey. More...
class	ExcForbiddenMethod
	Exception — Forbidden method called. More...
class	ExcHandleInitError
	Exception — Error initializing VarHandle from VarHandleKey. More...
class	ExcUninitKey
	Exception — Tried to create a handle from an uninitialized key. More...
class	ExcConstObject
	Exception — Tried to retrieve non-const pointer to const object. More...
class	ExcNullWriteHandle
	Exception — Attempt to dereference write handle before record. More...
class	ExcNullReadHandle
	Exception — Deference of read handle failed. More...
class	ExcNullUpdateHandle
	Exception — Deference of update handle failed. More...
class	ExcNonConstHandleKey
	Exception — Attempt to get non-const VarHandleKey from non-owning VarHandle. More...
class	ExcInvalidIterator
	Exception — Deference invalid SG::Iterator. More...
class	ExcBadInitializedReadHandleKey
	Exception — Initialization of InitializedReadHandleKey failed. More...
class	ExcBadContext
	Exception — Bad EventContext extension while building ReadCondHandle. More...
class	ExcNoCondCont
	Exception — Can't retrieve CondCont from ReadCondHandle. More...
class	ExcBadReadCondHandleInit
	Exception — ReadCondHandle didn't initialize in getRange(). More...
class	ExcNoRange
	Exception — Range not set in ReadCondHandle::getRange(). More...
class	ExcBadDecorElement
	Exception — DecorHandle given an element not in the requested container. More...
class	HandleKeyArray
class	MetaHandleKey
class	ReadCondHandle
class	ReadCondHandleKey
class	ReadDecorHandle
	Handle class for reading a decoration on an object. More...
class	ReadDecorHandleKey
	Property holding a SG store/key/clid/attr name from which a ReadDecorHandle is made. More...
class	ReadHandle
class	ReadHandleKey
	Property holding a SG store/key/clid from which a ReadHandle is made. More...
class	InitializedReadHandleKey
	ReadHandleKey that initializes during construction. More...
class	ReadMetaHandleKey
struct	HiveEventSlot
class	HiveMgrSvc
class	ConstIterator
	a const_iterator facade to DataHandle. More...
class	Iterator
	an iterator facade to DataHandle. More...
class	ShallowCopyDecorDeps
	Helper to propagate decoration dependencies to a shallow copy. More...
class	ThinningHandle
	Handle for requesting thinning for a data object. More...
class	ThinningHandleBase
	Handle for requesting thinning: factor out type-independent code. More...
class	ThinningHandleKey
	HandleKey object for adding thinning to an object. More...
class	TypelessWriteHandle
	Handle allowing writes to the event store with a configurable type. More...
class	TypelessWriteHandleKey
	Property holding a write key for which the type can be configured. More...
struct	IsThreadSafeForUH
struct	IsThreadSafeForUH< T, typename T::thread_safe >
class	UpdateHandle
class	UpdateHandleKey
	Property holding a SG store/key/clid from which an UpdateHandle is made. More...
class	VarHandleBase
	Base class for VarHandle types. More...
class	VarHandleKey
	A property holding a SG store/key/clid from which a VarHandle is made. More...
class	VarHandleKeyArray
class	VarHandleKeyArrayCommon
class	VarHandleKeyArrayProperty
class	VarHandleKeyProperty
	VarHandleKeyProperty is the class which wraps a SG::VarHandleKey. More...
class	WriteCondHandle
class	WriteCondHandleKey
class	WriteDecorHandle
	Handle class for adding a decoration to an object. More...
class	WriteDecorHandleKey
	Property holding a SG store/key/clid/attr name from which a WriteDecorHandle is made. More...
class	WriteHandle
class	WriteHandleKey
	Property holding a SG store/key/clid from which a WriteHandle is made. More...
class	PyDataBucket
	Concrete DataBucket that holds the object via a void* and uses the Root dictionary to do conversions. More...
struct	PyProxyMgr
	A helper class to manage accesses to PyProxies. More...
struct	PyProxyDict
	a python front-end to the IProxyDict interface PyProxyDict encapsulates getting python objects from the raw C++ ones ones gets from the C++ store. More...
class	ToTransient< xAOD::ShallowAuxInfo >
struct	Zero< Eigen::Matrix< SCALAR, ROWS, COLS, OPTIONS, MAXROWS, MAXCOLS > >
struct	Bases< TileContainer< T > >

Concepts
concept	IsConstAuxElement
	Test if T is compatible with ConstAuxElement.
concept	IsAuxElement
	Test if T is compatible with AuxElement.
concept	IsAuxDataVector
	Concept for "xAOD style" DataVector interface containers.

Typedefs
typedef void	iterator
typedef void	const_iterator
using	TypelessConstAccessor = ConstAuxElement::TypelessConstAccessor
template<class T, class ALLOC = AuxAllocator_t<T>>
using	ConstAccessor = SG::ConstAccessor<T, ALLOC>
template<class T, class ALLOC = AuxAllocator_t<T>>
using	Accessor = SG::Accessor<T, ALLOC>
template<class T, class ALLOC = AuxAllocator_t<T>>
using	Decorator = SG::Decorator<T, ALLOC>
	Helper class to provide type-safe access to aux data, specialized for JaggedVecElt.
typedef AthContainers_detail::mutex	mutex_t
	Mutex used to synchronize modifications to the cache vector.
typedef AthContainers_detail::lock_guard< mutex_t >	guard_t
using	const_span
	Helper class to provide constant type-safe access to aux data, specialized for a vector of PackedLink.
using	elt_span = detail::ELSpanProxy<CONT, VALLOC>
	Presents a vector of PackedLink as a range of ElementLink proxies.
using	ELSpanConverter = detail::ELSpanConverter<CONT, VALLOC>
	Transform a span over vector of PackedLink to a span over span over ElementLink proxies.
using	span
using	element_type = elt_span
	Type the user sees.
using	reference_type = elt_span
	Type referencing an item.
using	container_pointer_type = void
	Not supported.
using	const_container_pointer_type = void
template<class T>
using	AuxAllocator_t = std::allocator<T>
	The default allocator type to use for auxiliary variables.
template<class T, class ALLOC = AuxAllocator_t<T>, class CONT = typename AuxDataTraits<T, ALLOC>::vector_type>
using	AuxTypeVector = AuxTypeVectorT<AuxTypeVectorHolder<T, CONT> >
	Default type derives directly from AuxTypeVectorHolder.
template<class T, class ALLOC = AuxAllocator_t<JaggedVecElt<T> >>
using	JaggedVecVector = JaggedVecVectorT<JaggedVecVectorHolder<T, ALLOC> >
template<class CONT, class ALLOC = AuxAllocator_t<PackedLink<CONT> >>
using	PackedLinkVector = PackedLinkVectorT<PackedLinkVectorHolder<CONT, ALLOC> >
template<class CONT, class VALLOC = AuxAllocator_t<PackedLink<CONT> >, class VELT = typename AuxDataTraits<PackedLink<CONT>, VALLOC >::vector_type, class ALLOC = AuxAllocator_t<VELT>>
using	PackedLinkVVector = PackedLinkVectorT<PackedLinkVVectorHolder<CONT, VALLOC, VELT, ALLOC> >
typedef size_t	auxid_t
	Identifier for a particular aux data item.
template<CxxUtils::detail::RefCounted T>
using	DataObjectSharedPtr = CxxUtils::RefCountedPtr<T>
typedef std::string	SourceID
using	CompressionInfo = std::unordered_map<std::string, SG::ThinningInfo::compression_map_t>
	Map of compressed variables and their compression levels.
typedef ExcElementNotFound	maybe_thinning_error
	Backwards compatibility.
template<class T>
using	ConcurrentSGKeyMap
	A concurrent map using sgkey_t as key.
typedef uint32_t	sgkey_t
	Type used for hashed StoreGate key+CLID pairs.
template<class T>
using	SGKeyMap = std::unordered_map<sgkey_t, T>
	A map using sgkey_t as a key.
using	SGKeySet = std::unordered_set<sgkey_t>
	A set of sgkey_t values.
typedef std::map< std::string, DataProxy * >	ProxyMap
typedef ProxyMap::iterator	ProxyIterator
typedef ProxyMap::const_iterator	ConstProxyIterator
typedef IProxyDict **	getDataSourcePointerFunc_t(const std::string &)
template<class T>
using	ReadCondHandleKeyArray = HandleKeyArray<ReadCondHandle<T>, CondHandleDefault::Key<ReadCondHandleKey<T> >, Gaudi::DataHandle::Reader >
template<class T>
using	WriteCondHandleKeyArray = HandleKeyArray<WriteCondHandle<T>,CondHandleDefault::Key<WriteCondHandleKey<T> >, Gaudi::DataHandle::Writer >
template<class T_Handle, class T_HandleKey, Gaudi::DataHandle::Mode MODE>
using	DecorHandleKeyArray = HandleKeyArray< T_Handle, T_HandleKey, MODE>
template<class T, class S = float>
using	ReadDecorHandleKeyArray = DecorHandleKeyArray<ReadDecorHandle<T, S>, ReadDecorHandleKey<T>, Gaudi::DataHandle::Reader >
template<class T>
using	ReadHandleKeyArray = HandleKeyArray<ReadHandle<T>, ReadHandleKey<T>, Gaudi::DataHandle::Reader >
template<class T>
using	WPtr = T*
template<class T>
using	ThinningHandleKeyArray = HandleKeyArray<ThinningHandle<T>,ThinningHandleKey<T>, Gaudi::DataHandle::Reader >
template<class T, class S = float>
using	WriteDecorHandleKeyArray = DecorHandleKeyArray<WriteDecorHandle<T, S>,WriteDecorHandleKey<T>, Gaudi::DataHandle::Writer >
template<class T>
using	WriteHandleKeyArray = HandleKeyArray<WriteHandle<T>,WriteHandleKey<T>, Gaudi::DataHandle::Writer >

Enumerations
enum	IndexTrackingPolicy { DEFAULT_TRACK_INDICES , ALWAYS_TRACK_INDICES , NEVER_TRACK_INDICES }
enum	OwnershipPolicy { OWN_ELEMENTS , VIEW_ELEMENTS }
enum	AuxVarFlags { None = 0x00 , Atomic = 0x01 }
	Additional flags to qualify an auxiliary variable. More...
enum class	PrivateStoreState : uint8_t { NO_PRIVATE = 0 , HAVE_PRIVATE = 1 , HAD_PRIVATE = 2 }
	The current private data state. More...
enum class	InvalidSlot { Enabled , Disabled }
	Support of the invalid EventContext in SlotSpecificObj. More...
enum	AllowEmptyEnum { AllowEmpty = 1 }

Functions
template<>
bool	findInContainer (const CaloCellContainer &data, CaloCell const *const &element, CaloCellContainer::size_type &index)
template<>
bool	findInContainer (const CaloConstCellContainer &data, CaloCell const *const &element, CaloConstCellContainer::size_type &index)
template<>
bool	findInContainer (const CaloCellContainer &data, CaloCell const *const &element, CaloCellContainer::size_type &index)
std::ostream &	operator<< (std::ostream &os, const ArenaAllocatorBase::Stats::Stat &stat)
	Format a statistic structure.
std::ostream &	operator<< (std::ostream &os, const ArenaAllocatorBase::Stats &stats)
	Format a complete statistics structure.
	ArenaHeapAllocator (const Params &params)
	Constructor.
virtual	~ArenaHeapAllocator ()
	Destructor.
	ArenaHeapAllocator (const ArenaHeapAllocator &)=delete
	Don't allow copy construction or assignment.
ArenaHeapAllocator &	operator= (const ArenaHeapAllocator &)=delete
	ArenaHeapAllocator (ArenaHeapAllocator &&other)
	Move constructor.
ArenaHeapAllocator &	operator= (ArenaHeapAllocator &&other)
	Move assignment.
void	swap (ArenaHeapAllocator &other)
	Swap.
pointer	allocate ()
	Allocate a new element.
void	free (pointer p)
	Free an element.
virtual void	reset () override
	Free all allocated elements.
virtual void	erase () override final
	Free all allocated elements and release memory back to the system.
void	slowClear ()
	Call clear() for all allocated elements.
pointer	refill ()
	Add more free elements to the pool, and allocate a new element.
pointer &	link (pointer p) const
	Return a reference to the link for an element.
template<class T, class VETO>
void	maybeUnprotect (ArenaHeapSTLAllocator< T, VETO > &a)
	Hook for unprotecting an arena.
template<class T, class VETO>
void	maybeUnprotect (ArenaPoolSTLAllocator< T, VETO > &a)
	Hook for unprotecting an arena.
template<class T>
void	swap (ArenaSharedHeapSTLAllocator< T > &a, ArenaSharedHeapSTLAllocator< T > &b)
template<class T>
void	maybeUnprotect (ArenaSharedHeapSTLAllocator< T > &a)
	Hook for unprotecting an arena.
template<class ALLOC>
void	maybeUnprotect (ALLOC &)
	Hook for unprotecting an arena.
void	null_arena_deleter (ArenaBase *)
ArenaPoolAllocator::pointer	ArenaPoolAllocator_iterator_increment (ArenaPoolAllocator::pointer base, ArenaBlock *&block)
	Helper: common code for advancing an iterator.
ArenaPoolAllocator::const_pointer	ArenaPoolAllocator_iterator_increment (ArenaPoolAllocator::const_pointer base, const ArenaBlock *&block)
	Helper: common code for advancing an iterator.
std::string	excProtection_format (int errnum)
	AuxElement (SG::AuxVectorData *container, size_t index)
	Base class for elements of a container that can have aux data.
	AuxElement (const AuxElement &other)
	Copy Constructor.
AuxElement &	operator= (const AuxElement &other)
	Assignment.
void	assign (const AuxElement &other, bool warnUnlocked=false)
	Assignment.
	~AuxElement ()
	Destructor.
const SG::AuxVectorData *	container () const
	Return the container holding this element.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::reference_type	auxdata (const std::string &name)
	Fetch an aux data variable, as a non-const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::reference_type	auxdata (const std::string &name, const std::string &clsname)
	Fetch an aux data variable, as a non-const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type	auxdata (const std::string &name) const
	Fetch an aux data variable, as a const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type	auxdata (const std::string &name, const std::string &clsname) const
	Fetch an aux data variable, as a const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type	auxdataConst (const std::string &name) const
	Fetch an aux data variable, as a const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type	auxdataConst (const std::string &name, const std::string &clsname) const
	Fetch an aux data variable, as a const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED bool	isAvailable (const std::string &name, const std::string &clsname="") const
	Check if an aux variable is available for reading.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED bool	isAvailableWritable (const std::string &name, const std::string &clsname="")
	Check if an aux variable is available for writing.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED bool	isAvailableWritableAsDecoration (const std::string &name, const std::string &clsname="") const
	Check if an aux variable is available for writing as a decoration.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Decorator< T, ALLOC >::reference_type	auxdecor (const std::string &name) const
	Fetch an aux decoration, as a non-const reference.
template<class T, class ALLOC = AuxAllocator_t<T>>
XAOD_AUXDATA_DEPRECATED Decorator< T, ALLOC >::reference_type	auxdecor (const std::string &name, const std::string &clsname) const
	Fetch an aux decoration, as a non-const reference.
void	makePrivateStore ()
	Create a new (empty) private store for this object.
template<class U1>
void	makePrivateStore (const U1 &other, bool warnUnlocked=false)
	Create a new private store for this object and copy aux data.
template<class U1>
void	makePrivateStore (const U1 *other, bool warnUnlocked=false)
	Create a new private store for this object and copy aux data.
void	releasePrivateStore ()
	Release and free any private store associated with this object.
void	setStore (const SG::IConstAuxStore *store)
	Set the store associated with this object.
void	setStore (SG::IAuxStore *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.
bool	usingPrivateStore () const
	Test to see if this object is currently using a private store.
bool	usingStandaloneStore () const
	Test to see if this object is currently using a standalone store.
const SG::IConstAuxStore *	getConstStore () const
	Return the current store, as a const interface.
SG::IAuxStore *	getStore () const
	Return the current store, as a non-const interface.
void	clearCache ()
	Clear the cached aux data pointers.
const SG::auxid_set_t &	getAuxIDs () const
	Return a set of identifiers for existing data items for this object.
const SG::auxid_set_t &	getDecorIDs () const
	Return a set of identifiers for decorations for this object.
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	clearDecorations () const
	Clear all decorations.
bool	trackIndices () const
	Return true if index tracking is enabled for this object.
void	releasePrivateStoreForDtor ()
	Out-of-line portion of destructor.
void	setIndex (size_t index, SG::AuxVectorData *container)
	Set the index/container for this element.
bool	setIndexPrivate (size_t index, SG::AuxVectorData *container)
	Set the index/container for this element.
void	makePrivateStore1 (const void *other, bool warnUnlocked)
	Create a new private store for this object and copy aux data.
void	makePrivateStore1 (const AuxElement *other, bool warnUnlocked)
	Create a new private store for this object and copy aux data.
AuxElementStandaloneData *	setStore1 (const SG::IConstAuxStore *store)
	Set the store associated with this object.
void	clearAux ()
	Clear all aux data associated with this element.
void	copyAux (const ConstAuxElement &other, bool warnUnlocked=false)
	Copy aux data from another object.
static void	clearAuxHelper (AuxVectorData &container, size_t index)
	Clear all aux data associated with an element.
static void	copyAuxHelper (AuxVectorData &container, size_t index, const ConstAuxElement &other, bool warnUnlocked)
	Copy aux data from another object.
	AuxStoreInternal (bool standalone=false)
	An auxiliary data store that holds data internally.
virtual	~AuxStoreInternal ()
	Destructor.
	AuxStoreInternal (const AuxStoreInternal &orig)
	Copy constructor.
AuxStoreInternal &	operator= (const AuxStoreInternal &)=delete
	Don't allow assignment.
bool	standalone () const
	Return the standalone flag.
virtual const void *	getData (SG::auxid_t auxid) const override
	Return the data vector for one aux data item.
virtual const IAuxTypeVector *	getVector (SG::auxid_t auxid) const override
	Return vector interface for one aux data item.
virtual void *	getData (SG::auxid_t auxid, size_t size, size_t capacity) override
	Return the data vector for one aux data item.
virtual void *	getDecoration (auxid_t auxid, size_t size, size_t capacity) override
	Return the data vector for one aux data decoration item.
virtual bool	resize (size_t sz) override
	Change the size of all aux data vectors.
virtual void	reserve (size_t sz) override
	Change the capacity of all aux data vectors.
virtual void	shift (size_t pos, ptrdiff_t offs) override
	Shift the elements of the container.
virtual bool	insertMove (size_t pos, IAuxStore &other, const SG::auxid_set_t &ignore=SG::auxid_set_t(0)) override
	Move all elements from other to this store.
virtual SG::auxid_set_t	getCopyIDs (bool warnUnlocked=false) const override
	Return the set of variables to copy in a deep copy.
virtual bool	isDecoration (auxid_t auxid) const override
	Test if a particular variable is tagged as a decoration.
virtual const SG::auxid_set_t &	getWritableAuxIDs () const override
	Return a set of identifiers for writable data items in this store.
virtual const void *	getIOData (SG::auxid_t auxid) const override
	Return a pointer to the data to be stored for one aux data item.
virtual const std::type_info *	getIOType (SG::auxid_t auxid) const override
	Return the type of the data to be stored for one aux data item.
virtual const SG::auxid_set_t &	getDynamicAuxIDs () const override
	Get the list of all variables that need to be handled.
virtual void	lock () override
	Lock the container.
virtual size_t	size () const override
	Return the number of elements in the store.
virtual bool	setOption (auxid_t id, const AuxDataOption &option) override
	Set an option for an auxiliary data variable.
virtual void	lockDecoration (SG::auxid_t auxid) override
	Lock a decoration.
virtual IAuxTypeVector *	linkedVector (SG::auxid_t auxid) override
	Return interface for a linked variable.
void	toTransient (const EventContext &ctx, SG::auxid_t auxid)
	Perform post-read processing for a single variable.
virtual void	toTransient (const EventContext &ctx) override
	Perform post-read processing on this store.
const void *	getIODataInternal (auxid_t auxid, bool quiet) const
	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.
IAuxTypeVector *	addVector (std::unique_ptr< IAuxTypeVector > vec, bool isDecoration)
	Explicitly add a vector to the store.
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.
SG::auxid_set_t	getCopyIDs (const SG::auxid_set_t &auxids, const SG::auxid_set_t &decors, bool warnUnlocked, std::span< const std::string > noWarn)
	Compute the set of variables to copy in a deep copy.
template<class DV>
void	dataVectorViewAsELV (const std::true_type &, const DV &v, std::vector< ElementLink< DV > > &ret, IProxyDict *store)
	Helper for dataVectorViewAsELV.
template<class DV>
void	dataVectorViewAsELV (const std::false_type &, const DV &, std::vector< ElementLink< DV > > &, IProxyDict *)
	Helper for dataVectorViewAsELV.
template<class DV>
std::vector< ElementLink< DV > >	dataVectorAsELV (const DV &v, IProxyDict *store=0)
	Helper to make a vector<EL> from a DataVector.
	Decorator (const std::string &name)
	Helper class to provide type-safe access to aux data.
	Decorator (const std::string &name, const std::string &clsname)
	Constructor.
	Decorator (const SG::auxid_t auxid)
	Constructor taking an auxid directly.
template<IsConstAuxElement ELT>
reference_type	operator() (const ELT &e) const
	Fetch the variable for one element, as a non-const reference.
reference_type	operator() (const AuxVectorData &container, size_t index) const
	Fetch the variable for one element, as a non-const reference.
template<IsConstAuxElement ELT>
void	set (const ELT &e, const element_type &x) const
	Set the variable for one element.
const_container_pointer_type	getDataArray (const AuxVectorData &container) const
	Get a pointer to the start of the auxiliary data array.
container_pointer_type	getDecorationArray (const AuxVectorData &container) const
	Get a pointer to the start of the auxiliary data array.
const_span	getDataSpan (const AuxVectorData &container) const
	Get a span over the auxiliary data array.
span	getDecorationSpan (const AuxVectorData &container) const
	Get a span over the auxiliary data array.
template<IsConstAuxElement ELT>
bool	isAvailable (const ELT &e) const
	Test to see if this variable exists in the store.
template<IsConstAuxElement ELT>
bool	isAvailableWritable (const ELT &e) const
	Test to see if this variable exists in the store and is writable.
bool	isAvailable (const AuxVectorData &c) const
	Test to see if this variable exists in the store.
bool	isAvailableWritable (const AuxVectorData &c) const
	Test to see if this variable exists in the store and is writable.
SG::auxid_t	auxid () const
	Return the aux id for this variable.
	Decorator (const std::string &name, const std::string &clsname, const SG::AuxVarFlags flags)
	Constructor.
	Decorator (const SG::auxid_t auxid, const SG::AuxVarFlags flags)
	Constructor taking an auxid directly.
void	throwExcNonowningContainer ()
	Throw a SG::ExcNonowningContainer exception.
void	throwExcUnknownAuxItem (const std::string &name, const std::string &clsname="", const std::type_info *typ=0)
	Throw a SG::ExcUnknownAuxItem exception.
void	throwExcViewVectorNotView ()
	Throw a SG::ExcViewVectorNotView exception.
void	throwExcMissingViewVectorCLID (const std::type_info &ti)
	Throw a SG::ExcMissingViewVectorCLID exception.
void	throwExcMissingBaseInfo (const std::type_info &ti)
	Throw a SG::ExcMissingBaseInfo exception.
void	throwExcAllocOwnership ()
	Throw a SG::ExcAllocOwnership exception.
void	throwJaggedVecOverlappingCopy ()
	Throw a SG::ExcJaggedVecOverlappingCopy exception.
template<IsConstAuxElement ELT, CxxUtils::InputRangeOverT< PAYLOAD_T > RANGE>
void	set (const ELT &e, const RANGE &x) const
	Set the variable for one element.
template<CxxUtils::InputRangeOverT< PAYLOAD_T > RANGE>
void	set (const AuxVectorData &container, size_t index, const RANGE &x) const
	Set the variable for one element.
const Elt_t *	getEltArray (const AuxVectorData &container) const
	Get a pointer to the start of the array of JaggedVecElt objects.
const Payload_t *	getPayloadArray (const AuxVectorData &container) const
	Get a pointer to the start of the payload array.
Elt_t *	getEltDecorArray (const AuxVectorData &container) const
	Get a pointer to the start of the array of JaggedVecElt objects, as a decoration.
Payload_t *	getPayloadDecorArray (const AuxVectorData &container) const
	Get a pointer to the start of the payload array, as a decoration.
const_Elt_span	getEltSpan (const AuxVectorData &container) const
	Get a span over the array of JaggedVecElt objects.
const_Payload_span	getPayloadSpan (const AuxVectorData &container) const
	Get a span over the payload vector.
Elt_span	getEltDecorSpan (const AuxVectorData &container) const
	Get a span over the array of JaggedVecElt objects, as a decoration.
Payload_span	getPayloadDecorSpan (const AuxVectorData &container) const
	Get a span over the payload vector, as a decoration.
std::string	normalizedTypeinfoName (const std::type_info &info)
	Convert a type_info to a normalized string representation (matching the names used in the root dictionary).
template<IsConstAuxElement ELT>
ELProxy	operator() (const ELT &e) const
	Fetch the variable for one element.
void	set (const AuxVectorData &container, size_t index, const Link_t &x) const
	Set the variable for one element.
const PLink_t *	getPackedLinkArray (const AuxVectorData &container) const
	Get a pointer to the start of the array of PackedLinks.
const DLink_t *	getDataLinkArray (const AuxVectorData &container) const
	Get a pointer to the start of the linked array of DataLinks.
PLink_t *	getPackedLinkDecorArray (const AuxVectorData &container) const
	Get a pointer to the start of the array of PackedLinks, as a decoration.
DLink_t *	getDataLinkDecorArray (const AuxVectorData &container) const
	Get a pointer to the start of the linked array of DataLinks, as a decoration.
const_PackedLink_span	getPackedLinkSpan (const AuxVectorData &container) const
	Get a span over the array of PackedLinks.
const_DataLink_span	getDataLinkSpan (const AuxVectorData &container) const
	Get a span over the array of DataLinks.
PackedLink_span	getPackedLinkDecorSpan (const AuxVectorData &container) const
	Get a span over the array of PackedLinks, as a decoration.
DataLink_span	getDataLinkDecorSpan (const AuxVectorData &container) const
	Get a span over the array of DataLinks, as a decoration.
template<IsConstAuxElement ELT>
elt_span	operator() (const ELT &e) const
	Fetch the variable for one element.
template<IsConstAuxElement ELT, detail::ElementLinkRange< CONT > RANGE>
void	set (const ELT &e, const RANGE &x) const
	Set the variable for one element.
template<detail::ElementLinkRange< CONT > RANGE>
void	set (const AuxVectorData &container, size_t index, const RANGE &r) const
	Set the variable for one element.
const VElt_t *	getPackedLinkVectorArray (const AuxVectorData &container) const
	Get a pointer to the start of the array of vectors of PackedLinks.
VElt_t *	getPackedLinkVectorDecorArray (const AuxVectorData &container) const
	Get a pointer to the start of the array of vectors of PackedLinks, as a decoration.
template<IsConstAuxElement ELT>
const_PackedLink_span	getPackedLinkSpan (const ELT &e) const
	Get a span over the vector of PackedLinks for a given element.
const_PackedLink_span	getPackedLinkSpan (const AuxVectorData &container, size_t index) const
	Get a span over the vector of PackedLinks for a given element.
PackedLink_span	getPackedLinkSpan (AuxVectorData &container, size_t index) const
	Get a span over the vector of PackedLinks for a given element.
const_PackedLinkVector_span	getPackedLinkVectorSpan (const AuxVectorData &container) const
	Get a span over the vectors of PackedLinks.
template<IsConstAuxElement ELT>
PackedLink_span	getPackedLinkDecorSpan (const ELT &e) const
	Get a span over the vector of PackedLinks for a given element, as a decoration.
PackedLink_span	getPackedLinkDecorSpan (const AuxVectorData &container, size_t index) const
	Get a span over the vector of PackedLinks for a given element, as a decoration.
PackedLinkVector_span	getPackedLinkVectorDecorSpan (const AuxVectorData &container) const
	Get a span over the vectors of PackedLinks, as a decoration.
void	copyAuxStoreThinned (const SG::IConstAuxStore &orig, SG::IAuxStore &copy, const SG::ThinningInfo *info)
	Helper to copy an aux store while applying thinning.
void	lossyFloatCompress (void *dst, const std::size_t dst_index, const std::size_t n, const std::size_t eltSize, const std::string &typeName, const unsigned int nmantissa)
	Helper method to apply lossy float compression.
template<class CONTAINER>
std::unique_ptr< CONTAINER >	copyThinned (CONTAINER &orig, const SG::ThinningInfo *info)
	Helper to copy an object while applying thinning.
template<class CONTAINER>
std::unique_ptr< const CONTAINER >	copyThinnedConst (const CONTAINER &orig, const SG::ThinningInfo *info)
	Helper to copy an object while applying thinning, const version.
template<class CONTAINER>
std::unique_ptr< CONTAINER >	copyThinned1 (const CONTAINER &orig, const void *dummy, const SG::ThinningInfo *info)
	Helper to copy an object while applying thinning.
template<class CONTAINER>
std::unique_ptr< CONTAINER >	copyThinned1 (CONTAINER &orig, DataVector< typename CONTAINER::base_value_type > *, const SG::ThinningInfo *info)
	Helper to copy an object while applying thinning.
template<class CONTAINER>
std::unique_ptr< const CONTAINER >	copyThinned1 (const CONTAINER &orig, const DataVector< typename CONTAINER::base_value_type > *dummy, const SG::ThinningInfo *info)
	Helper to copy an object while applying thinning.
template<class CONTAINER>
std::unique_ptr< CONTAINER >	copyThinned1 (const CONTAINER &orig, const SG::IAuxStore *dummy, const SG::ThinningInfo *info)
	Helper to copy an object while applying thinning.
template<class T>
bool constexpr	xAODInterfaceSupportingThinning ()
	Test for an xAOD interface class supporting thinning.
template<class T, typename std::enable_if_t< is_xAODStoreObject_v< T > > * = nullptr>
bool constexpr	xAODStoreSupportingThinning ()
void	writePackedParameters (TBuffer &b, const SG::PackedParameters &parms)
	Write a set of packed parameters to a buffer.
SG::PackedParameters	readPackedParameters (TBuffer &b)
	Read a set of packed parameters from a buffer.
void	ViewVectorBaseStreamerFunc (TBuffer &b, void *p)
std::string	excFormatName (SG::auxid_t auxid)
	Helper: format an aux data item name.
std::string	excNoAuxStore_format (SG::auxid_t auxid)
	Helper: format exception error string.
std::string	excNoAuxStore_format (const char *op)
	Helper: format exception error string.
std::string	excBadAuxVar_format (SG::auxid_t auxid)
	Helper: format exception error string.
std::string	excConstAuxData_format (const std::string &op, SG::auxid_t auxid)
	Helper: format exception error string.
std::string	excAuxTypeMismatch_format (SG::auxid_t auxid, const std::type_info &new_type, const std::type_info &old_type, const std::string &new_alloc_type, const std::string &old_alloc_type)
	Helper: format exception error string.
std::string	excInsertionInBaseClass_format (const char *op, const std::type_info &base_type, const std::type_info &complete_type)
	Helper: format exception error string.
std::string	excStoreLocked_format (SG::auxid_t auxid)
	Helper: format exception error string.
std::string	excStoreLocked_format (const char *op)
	Helper: format exception error string.
std::string	excUnknownAuxItem_format (const std::string &name, const std::string &clsname, const std::type_info *typ)
	Helper: format exception error string.
std::string	excDVToELV_format (const std::string &detail)
	Helper: format exception error string.
std::string	excFormatFlags (SG::AuxVarFlags flags)
	Helper: format flags.
std::string	excFlagMismatch_format (SG::auxid_t auxid, const std::type_info &type, SG::AuxVarFlags existing_flags, SG::AuxVarFlags requested_flags)
	Helper: format exception error string.
std::string	excLinkMismatch_format (SG::auxid_t auxid, const std::type_info &type, SG::auxid_t existing_linked_id, SG::auxid_t requested_linked_id)
	Helper: format exception error string.
std::string	excNoLinkedVar_format (SG::auxid_t auxid, const std::type_info &type)
	Helper: format exception error string.
std::string	excInvalidThinningTarget_format (unsigned int clid, const std::string &key)
	Helper: format exception error string.
std::string	excBadVarName_format (const std::string &name)
	Helper: format exception error string.
std::string	excJaggedVecOverlappingCopy_format ()
	Helper: format exception error string.
void copyAuxStoreThinned	NO_SANITIZE_UNDEFINED (const SG::IConstAuxStore &orig, SG::IAuxStore &copy, const SG::ThinningInfo *info)
	Helper to copy an aux store while applying thinning.
	IAuxElement ()
	Flag that a class may have auxiliary data associated with it.
	IAuxElement (size_t index)
	Constructor.
size_t	index () const
	Return the index of this element within its container.
bool	noPrivateData () const
	True if this element has no private data.
bool	havePrivateData () const
	True if this element currently has private data.
bool	hadPrivateData () const
	True if this element had private data before it was added to its current container.
void	setIndex (size_t index)
	Set the index of this element within its container.
void	setNoPrivateData ()
	Record that this element does not have private data.
void	setHavePrivateData ()
	Record that this element currently has private data.
void	setHadPrivateData ()
	Record that this element used to have private data.
template<class T, class U>
constexpr bool	noToTransient1 (U)
template<class T>
constexpr bool	noToTransient1 (int, typename T::noToTransient=typename T::noToTransient())
template<class T>
constexpr bool	noToTransient ()
	Helper to test if T::noToTransient exists as a typedef.
SG::auxid_t	getDynamicAuxID (const std::type_info &ti, const std::string &name, const std::string &elementTypeName, const std::string &branch_type_name, bool standalone, SG::auxid_t linked_auxid)
	Find the auxid for a dynamic branch.
TClass *	getClassIfDictionaryExists (const std::string &cname)
	Look up a TClass given a name.
template<typename T>
DataObject *	asStorable (SG::DataObjectSharedPtr< T > pObject)
const SG::ThinningCache *	getThinningCache (const EventContext &ctx)
	Retrieve the current thinning cache from the event context.
const SG::ThinningCache *	getThinningCache ()
	Retrieve the current thinning cache from the current event context.
const SG::ThinningInfo *	getThinningInfo (const EventContext &ctx, const std::string &key)
	Retrieve the current thinning information for key.
const SG::ThinningInfo *	getThinningInfo (const std::string &key)
	Retrieve the current thinning information for key.
const SG::ThinningDecisionBase *	getThinningDecision (const EventContext &ctx, const std::string &key)
	Retrieve the current thinning decision for key.
const SG::ThinningDecisionBase *	getThinningDecision (const std::string &key)
	Retrieve the current thinning decision for key.
const SG::ThinningDecisionBase *	getThinningDecision (const EventContext &ctx, const sgkey_t sgkey)
	Retrieve the current thinning decision for sgkey.
const SG::ThinningDecisionBase *	getThinningDecision (const sgkey_t sgkey)
	Retrieve the current thinning decision for sgkey.
size_t	getNSlots ()
	Return the number of event slots.
void setNSlotsHiveMgrName	ATLAS_NOT_THREAD_SAFE (const std::string &s)
	Allow setting the name of the whiteboard service.
template<typename T>
DataObject *	asStorable (T *pObject)
template<typename T>
bool	fromStorable (DataObject *pDObj, T *&pTrans, bool quiet=false, IRegisterTransient *irt=0, bool isConst=true)
template<typename T>
T *	Storable_cast (DataObject *pDObj, bool quiet=true, IRegisterTransient *irt=0, bool isConst=true)
void *	fromStorable (DataObject *pDObj, CLID clid, const std::type_info *tinfo=nullptr, bool quiet=false, IRegisterTransient *irt=0, bool isConst=true)
	Try to get the pointer back from a DataObject, converted to be of type clid.
void *	Storable_cast (DataObject *pDObj, CLID clid, const std::type_info *tinfo=nullptr, bool quiet=false, IRegisterTransient *irt=0, bool isConst=true)
	Try to get the pointer back from a DataObject, converted to be of type clid.
template<typename T>
DataObject *	asStorable (std::unique_ptr< T > pObject)
template<class T>
constexpr CLID	safe_clid ()
	Return the class ID of T, or CLID_NULL if it doesn't have one.
void	dumpBaseInfo ()
size_t	getNSlots_once ()
	Return the number of event slots.
void	throwExcInvalidLink (CLID clid, const std::string &key, SG::sgkey_t sgkey)
	Throw a SG::ExcInvalidLink exception.
void	throwExcBadForwardLink (size_t index, size_t size, const std::string &name)
	Throw a SG::ExcBadForwardLink exception.
void	throwExcElementNotFound (const char *where)
	Throw a SG::ExcElementNotFound exception.
void	throwExcInvalidIndex (const char *where)
	Throw a SG::ExcInvalidIndex exception.
void	throwExcIndexNotFound (const char *where)
	Throw a SG::ExcIndexNotFound exception.
void	throwExcIncomparableEL ()
	Throw a SG::IncomparableEL exception.
void	throwExcBadToTransient ()
	Throw a SG::ExcBadToTransient exception.
void	throwExcBadThinning (CLID clid, const std::string &key, SG::sgkey_t sgkey)
	Throw a SG::ExcBadThinning exception.
void setDataProxyHolderInputRenameMap	ATLAS_NOT_THREAD_SAFE (const Athena::IInputRename::InputRenameRCU_t *map)
	Set map used for performing input renaming in toTransient.
template<typename CONT, typename ELT>
bool	findInContainer (const CONT &data, const ELT &element, typename CONT::size_type &index)
	Find the index of an object within a container.
void	AthLinks_error ()
	For setting debugger breakpoints.
std::string	excPointerNotInSG_format (const void *pointer)
	Helper: format exception error string.
std::string	excCLIDMismatch_format (CLID obj_clid, CLID link_clid)
	Helper: format exception error string.
std::string	excInvalidLink_format (CLID clid, const std::string &key, SG::sgkey_t sgkey)
	Helper: format exception error string.
std::string	excBadForwardLink_format (size_t index, size_t size, const std::string &name)
	Helper: format exception error string.
std::string	excConstStorable_format (CLID clid, const std::string &key, SG::sgkey_t sgkey)
	Helper: format exception error string.
std::string	excBadThinning_format (CLID clid, const std::string &key, SG::sgkey_t sgkey)
	Helper: format exception error string.
std::ostream &	operator<< (std::ostream &out, const VarHandleBase &o)
	Return the name of the store holding the object we are proxying.
bool	operator== (const VarHandleBase &l, const VarHandleBase &r)
	Equality comparison.
bool	operator!= (const VarHandleBase &l, const VarHandleBase &r)
	Inequality comparison.
constexpr bool	sgkeyEqual (const sgkey_t a, const sgkey_t b)
	Compare two sgkeys for equality.
constexpr bool	sgkeyLess (const sgkey_t a, const sgkey_t b)
	Compare two sgkeys for ordering.
constexpr uint32_t	sgkeyShort (const sgkey_t k)
	Convert a sgkey to the 32-bit form used for older data.
template<typename DATA>
DATA *	DataProxy_cast (DataProxy *proxy)
	cast the proxy into the concrete data object it proxies
template<typename DATA>
DATA	DataProxy_cast (const DataProxy &proxy)
	const ref version of the cast.
void *	DataProxy_cast (DataProxy *proxy, CLID clid, const std::type_info *tinfo=nullptr)
	Try to get the pointer back from a DataProxy, converted to be of type clid.
void	throwExcBadDataProxyCast (const DataProxy &proxy, const std::type_info &tid)
	Throw an ExcBadDataProxyCast exception.
std::ostream &	operator<< (std::ostream &ost, const SG::VersionedKey &k)
IOpaqueAddress *TransientAddress::address	ATLAS_NOT_CONST_THREAD_SAFE () const
	Retrieve IOpaqueAddress.
std::string	excBadDataProxyCast_format (CLID id, const std::type_info &tid)
	Helper: Format exception string.
std::string	excProxyCollision_format (CLID id, const std::string &key, CLID primary_id, const std::string &primary_key)
	Helper: Format exception string.
std::string	excSgkeyCollision_format (const std::string &new_key, CLID new_clid, const std::string &old_key, CLID old_clid, sgkey_t sgkey)
	Helper: Format exception string.
std::string	contKeyFromKey (const std::string &key)
	Extract the container part of key.
std::string	decorKeyFromKey (const std::string &key, const std::string &deflt)
	Extract the decoration part of key.
std::string	makeContDecorKey (const std::string &cont, const std::string &decor)
	Make a StoreGate key from container and decoration name.
std::string	makeContDecorKey (const VarHandleKey &contKey, const std::string &key)
	Make a StoreGate key from container and decoration.
void	removeContFromDecorKey (const VarHandleKey &contKey, std::string &key)
	Remove container name from decoration key.
void	throwExcNullHandleKey ()
	Throw a SG::ExcNullHandleKey exception.
std::string	excHandleInitError_format (CLID clid, const std::string &sgkey, const std::string &storename)
	Helper: format exception error string.
std::string	excUninitKey_format (CLID clid, const std::string &sgkey, const std::string &storename, const std::string &holdername, const std::string &htype)
	Helper: format exception error string.
std::string	excConstObject_format (CLID clid, const std::string &sgkey, const std::string &storename)
	Helper: format exception error string.
std::string	excNullWriteHandle_format (CLID clid, const std::string &sgkey, const std::string &storename)
	Helper: format exception error string.
void	throwExcNullWriteHandle (CLID clid, const std::string &sgkey, const std::string &storename)
	Throw a SG::ExcNullWriteHandle exception.
std::string	excNullReadHandle_format (CLID clid, const std::string &sgkey, const std::string &storename)
	Helper: format exception error string.
void	throwExcNullReadHandle (CLID clid, const std::string &sgkey, const std::string &storename)
	Throw a SG::ExcNullReadHandle exception.
std::string	excNullUpdateHandle_format (CLID clid, const std::string &sgkey, const std::string &storename)
	Helper: format exception error string.
void	throwExcNullUpdateHandle (CLID clid, const std::string &sgkey, const std::string &storename)
	Throw a SG::ExcNullUpdateHandle exception.
std::string	excNonConstHandleKey_format (CLID clid, const std::string &sgkey, const std::string &storename)
	Helper: format exception error string.
void	throwExcNonConstHandleKey (CLID clid, const std::string &sgkey, const std::string &storename)
	Throw a SG::ExcNonConstHandleKey exception.
std::string	excBadContext_format (const EventContext &ctx, const std::string &key)
	Helper: format exception error string.
std::string	excNoCondCont_format (const std::string &key, const std::string &why)
	Helper: format exception error string.
std::string	excBadDecorElement_format (Gaudi::DataHandle::Mode mode, CLID clid, const std::string &decorKey)
	Helper: format exception error string.
void	throwExcBadDecorElement (Gaudi::DataHandle::Mode mode, CLID clid, const std::string &decorKey)
	Throw a SG::ExcBadDecorElement exception.
void	ReadCondHandleNotFound (const CondContBase &cc, const EventIDBase &eid, const std::string &key)
	Report a conditions container lookup failure.
template<class T>
SG::ReadCondHandle< T >	makeHandle (const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
template<class T>
const T *	get (const ReadCondHandleKey< T > &key, const EventContext &ctx)
	Convenience function to retrieve an object given a ReadCondHandleKey.
template<class T>
StatusCode	get (const T *&ptr, const ReadCondHandleKey< T > &key, const EventContext &ctx)
	Convenience function to retrieve an object given a ReadCondHandleKey.
template<class D, class T>
ReadDecorHandle< T, D >	makeHandle (const ReadDecorHandleKey< T > &key)
	Return a ReadDecorHandle referencing key.
template<class D, class T>
ReadDecorHandle< T, D >	makeHandle (const ReadDecorHandleKey< T > &key, const EventContext &ctx)
	Return a ReadDecorHandle referencing key for an explicit context.
template<class T>
void	makeHandle (const ReadDecorHandleKey< T > &key)
	These two signatures are to catch cases where the explicit template argument is omitted from the makeHandle call and give an error tailored to that.
template<class T>
void	makeHandle (const ReadDecorHandleKey< T > &key, const EventContext &ctx)
template<class T>
ReadHandle< T >	makeHandle (const ReadHandleKey< T > &key)
	Return a ReadHandle referencing key.
template<class T>
ReadHandle< T >	makeHandle (const ReadHandleKey< T > &key, const EventContext &ctx)
	Return a ReadHandle referencing key for an explicit context.
template<class T>
const T *	get (const ReadHandleKey< T > &key)
	Convenience function to retrieve an object given a ReadHandleKey.
template<class T>
const T *	get (const ReadHandleKey< T > &key, const EventContext &ctx)
	Convenience function to retrieve an object given a ReadHandleKey.
template<class T>
StatusCode	get (const T *&ptr, const ReadHandleKey< T > &key, const EventContext &ctx)
	Convenience function to retrieve an object given a ReadHandleKey.
template<class T>
ThinningHandle< T >	makeHandle (const ThinningHandleKey< T > &key)
	Return a ThinningHandle referencing key.
template<class T>
ThinningHandle< T >	makeHandle (const ThinningHandleKey< T > &key, const EventContext &ctx)
	Return a ThinningHandle referencing key for an explicit context.
int	simpleStringHash (const std::string &str, int maxInt=0xFFFF)
	simple hash function derived from Sedgewick Algorithms in C++ 3rd ed
template<class T>
UpdateHandle< T >	makeHandle (const UpdateHandleKey< T > &key)
	Return an UpdateHandle referencing key.
template<class T>
UpdateHandle< T >	makeHandle (const UpdateHandleKey< T > &key, const EventContext &ctx)
	Return an UpdateHandle referencing key for an explicit context.
template<class T>
SG::WriteCondHandle< T >	makeHandle (const SG::WriteCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
template<class D, class T>
WriteDecorHandle< T, D >	makeHandle (const WriteDecorHandleKey< T > &key)
	Return a WriteDecorHandle referencing key.
template<class D, class T>
WriteDecorHandle< T, D >	makeHandle (const WriteDecorHandleKey< T > &key, const EventContext &ctx)
	Return a WriteDecorHandle referencing key for an explicit context.
template<class T>
void	makeHandle (const WriteDecorHandleKey< T > &key)
	These two signatures are to catch cases where the explicit template argument is omitted from the makeHandle call and give an error tailored to that.
template<class T>
void	makeHandle (const WriteDecorHandleKey< T > &key, const EventContext &ctx)
template<class T>
WriteHandle< T >	makeHandle (const WriteHandleKey< T > &key)
	Return a WriteHandle referencing key.
template<class T>
WriteHandle< T >	makeHandle (const WriteHandleKey< T > &key, const EventContext &ctx)
	Return a WriteHandle referencing key for an explicit context.
template<>
void	ArenaAllocatorBase::destroy_fcn< HepMC::GenParticle > (ArenaAllocatorBase::pointer p)
template<>
void	ArenaAllocatorBase::destroy_fcn< HepMC::GenVertex > (ArenaAllocatorBase::pointer p)
template<>
void	ArenaAllocatorBase::destroy_fcn< HepMC::GenEvent > (ArenaAllocatorBase::pointer p)

Variables
static const int	ArenaBlockBodyOffset
	The offset from the start of the block to the first element.
pointer	m_freeptr
	Pointer to the next free element.
static constexpr bool	supportsThinning = true
	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.
bool	m_standalone
	Are we being written in standalone mode?
std::vector< std::unique_ptr< IAuxTypeVector > >	m_vecs
	The collection of vectors of aux data that we're managing, indexed by auxid.
SG::auxid_set_t	m_decorations
	Record which variables are decorations.
SG::auxid_set_t	m_auxids
	Set of auxid's for which we've created a vector.
bool	m_locked
	Has this container been locked?
mutex_t	m_mutex
SG::auxid_t	m_auxid
	The cached auxid.
constexpr const char *	auxAllocatorNamePrefix = "std::allocator<"
template<class T>
constexpr bool	is_xAODStoreObject_v
	Test for an xAOD auxiliary store class supporting thinning.
InstallViewVectorBaseStreamer	viewVectorBaseStreamerInstance
static const auxid_t	null_auxid = static_cast<auxid_t> (-1)
	To signal no aux data item.
static const auxid_t	auxid_set_size_hint = 2048
	A hint for how large we should make the auxid bitsets.
size_t	m_index
	The index of this element within its container. Should be 0 if this object is not within a container.
PrivateStoreState	m_privateStoreState
const std::string	DEFAULTKEY = ""
static constexpr auto	s_sgkey_nullval
static IProxyDict *	m_curStore = nullptr
	The current event store.
getDataSourcePointerFunc_t *	getDataSourcePointerFunc
static constexpr bool	defaultQuiet = false

Detailed Description

Forward declaration.

Namespace used by StoreGate for some of its internal structures/classes.

Typedef Documentation

Accessor

template<class T, class ALLOC = AuxAllocator_t<T>>

using SG::Accessor = SG::Accessor<T, ALLOC>

Definition at line 573 of file AuxElement.h.

AuxAllocator_t

template<class T>

using SG::AuxAllocator_t = std::allocator<T>

The default allocator type to use for auxiliary variables.

Definition at line 28 of file AuxDataTraits.h.

auxid_t

typedef size_t SG::auxid_t

Identifier for a particular aux data item.

Definition at line 27 of file AuxTypes.h.

AuxTypeVector

template<class T, class ALLOC = AuxAllocator_t<T>, class CONT = typename AuxDataTraits<T, ALLOC>::vector_type>

using SG::AuxTypeVector = AuxTypeVectorT<AuxTypeVectorHolder<T, CONT> >

Default type derives directly from AuxTypeVectorHolder.

Definition at line 389 of file AuxTypeVector.h.

CompressionInfo

using SG::CompressionInfo = std::unordered_map<std::string, SG::ThinningInfo::compression_map_t>

Map of compressed variables and their compression levels.

Definition at line 37 of file CompressionInfo.h.

ConcurrentSGKeyMap

template<class T>

using SG::ConcurrentSGKeyMap

Initial value:

CxxUtils::ConcurrentMap<
   sgkey_t, T,
   CxxUtils::SimpleUpdater,
   SGKeyHash, SGKeyEqual,
   0, s_sgkey_nullval>

A concurrent map using sgkey_t as key.

Definition at line 29 of file sgkey_utilities.h.

const_container_pointer_type

using SG::const_container_pointer_type = void

protected

Definition at line 441 of file PackedLinkDecorator.h.

const_iterator

typedef void SG::const_iterator

Definition at line 190 of file ArenaHeapAllocator.h.

const_span

using SG::const_span

protected

Initial value:

 
CxxUtils::transform_view_with_at<const_PackedLinkVector_span, ConstVectorTransform_t>

Helper class to provide constant type-safe access to aux data, specialized for a vector of PackedLink.

This is like Accessor, except that it only `decorates' the container. What this means is that this object can operate on a const container and return a non-const reference. However, if the container is locked, this will only work if either this is a reference to a new variable, in which case it is marked as a decoration, or it is a reference to a variable already marked as a decoration.

Although the type argument is PackedLink<CONT>, the objects that this accessor produces are ElementLink<CONT> (returned by value rather than by const reference). The getDataSpan method will then produce a (writable) span over ElementLink<CONT>. (There are separate methods for returning spans over the PackedLink/DataLink arrays themselves.)

You might use this something like this:

// Only need to do this once.
using Cont_t = std::vector<int>;
static const SG::Decorator<std::vector<SG::PackedLink<Cont_t> > links ("links");
...
const DataVector<MyClass></em> v = ...;
const Myclass* m = v->at(2);
links (*m).push_back (ElementLink<Cont_t> (...));
auto span = links.getDataSpan (*v);
span[2][1] = ElementLink<Cont_t> (...);

You can also use this to define getters/setters in your class:

*

class Myclass {
  ...
  auto get_links() const
  { const static ConstAccessor<SG::PackedLink<Cont_t> > acc ("links");
    return acc (*this); }
  void set_links (const std::vector<ElementLink<Cont_t> >& elv)
  { const static Accessor<std::vector<SG::PackedLink<Cont_t> > > acc ("links");
    acc (*this) = elv; }

*/ template <class CONT, class ALLOC, class VALLOC> class Decorator<std::vector<PackedLink<CONT>, VALLOC>, ALLOC> : public detail::LinkedVarAccessorBase { public: Aliases for the types we're dealing with. using Link_t = ElementLink<CONT>; using PLink_t = SG::PackedLink<CONT>; using VElt_t = std::vector<SG::PackedLink<CONT>, VALLOC>; using DLink_t = DataLink<CONT>; using DLinkAlloc_t = typename std::allocator_traits<ALLOC>::template rebind_alloc<DLink_t>;

/ Spans over the objects that are actually stored. using const_PackedLinkVector_span = typename AuxDataTraits<VElt_t, ALLOC>::const_span; using const_DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::const_span; using PackedLinkVector_span = typename AuxDataTraits<VElt_t, ALLOC>::span; using DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::span;

/ And spans over PackedLink objects. using const_PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, VALLOC>::const_span; using PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, VALLOC>::span;

/ Converter from vector of PackedLink to a span over ElementLinks. using ConstVectorTransform_t = detail::PackedLinkVectorConstConverter<CONT>;

/** Transform a span over vector of PackedLink to a span over span over ElementLink.

Definition at line 418 of file PackedLinkDecorator.h.

ConstAccessor

template<class T, class ALLOC = AuxAllocator_t<T>>

using SG::ConstAccessor = SG::ConstAccessor<T, ALLOC>

Definition at line 570 of file AuxElement.h.

ConstProxyIterator

typedef ProxyMap::const_iterator SG::ConstProxyIterator

Definition at line 24 of file ProxyMap.h.

container_pointer_type

using SG::container_pointer_type = void

protected

Not supported.

Definition at line 440 of file PackedLinkDecorator.h.

DataObjectSharedPtr

template<CxxUtils::detail::RefCounted T>

using SG::DataObjectSharedPtr = CxxUtils::RefCountedPtr<T>

Definition at line 27 of file DataObjectSharedPtr.h.

Decorator

template<class T, class ALLOC = AuxAllocator_t<T>>

SG::Decorator = SG::Decorator<T, ALLOC>

Helper class to provide type-safe access to aux data, specialized for JaggedVecElt.

Helper class to provide type-safe access to aux data, specialized for PackedLink.

Constructor taking an auxid directly.

Constructor.

This is a version of Decorator, specialized for jagged vectors.

This is like Accessor, except that it only `decorates' the container. What this means is that this object can operate on a const container and return a non-const reference. However, if the container is locked, this will only work if either this is a reference to a new variable, in which case it is marked as a decoration, or it is a reference to a variable already marked as a decoration.

Although the type argument is JaggedVecElt<PAYLOAD_T>, the objects that this accessor produces are spans over elements of type PAYLOAD_T. The getDataSpan method will then produce a (writable) span over spans of PAYLOAD_T. (There are separate methods for returning spans over the element/payload arrays themselves.)

You might use this something like this:

// Only need to do this once.
using Cont_t = std::vector<int>;
static const SG::Decorator<SG::JaggedVecElt<Cont_t> jvec ("jvec");
...
const DataVector<MyClass></em> v = ...;
const Myclass* m = v->at(2);
jvec (*m)[3] = 10;
for (auto sp : jvec.getDataSpan (*v)) {
  for (int& x : sp) ...
}

*/ template <class PAYLOAD_T, class ALLOC> class Decorator<JaggedVecElt<PAYLOAD_T>, ALLOC> : public detail::LinkedVarAccessorBase { public: / Payload type. using Payload_t = PAYLOAD_T;

/ Allocator to use for the payload vector. using PayloadAlloc_t = typename std::allocator_traits<ALLOC>::template rebind_alloc<Payload_t>;

/ One element of the jagged vector. using Elt_t = SG::JaggedVecElt<PAYLOAD_T>;

/ Writable proxies for a jagged vector element: both a single proxy / and one used as part of a span. using JVecProxy = detail::JaggedVecProxyT<Payload_t, detail::JaggedVecProxyValBase>; using JVecProxyInSpan = detail::JaggedVecProxyT<Payload_t, detail::JaggedVecProxyRefBase>;

/ Converter from JaggedVecElt to a (writable) span. using Converter_t = detail::JaggedVecConverter<Payload_t>;

/ Converter from JaggedVecElt to a span. using ConstConverter_t = detail::JaggedVecConstConverter<Payload_t>;

/ Spans over the objects that are actually stored. using const_Elt_span = typename AuxDataTraits<JaggedVecElt<Payload_t>, ALLOC>::const_span; using const_Payload_span = typename AuxDataTraits<Payload_t, PayloadAlloc_t>::const_span; using Elt_span = typename AuxDataTraits<JaggedVecElt<Payload_t>, ALLOC>::span; using Payload_span = typename AuxDataTraits<Payload_t, PayloadAlloc_t>::span;

/ Spans over the entire jagged vector, both writable and not. using const_span = CxxUtils::transform_view_with_at<const_Elt_span, ConstConverter_t>; using span = CxxUtils::transform_view_with_at<Elt_span, Converter_t>;

/ Const span resulting from the conversion. using element_type = typename ConstConverter_t::element_type;

/ Type referencing an item (const). using const_reference_type = element_type;

/ The writable type we return. using reference_type = JVecProxy;

/ A const reference type that can appear on the RHS of an assignment / to an application of a Decorator of this type. using rhs_const_reference_type = std::span<const Payload_t>;

/ Not supported. using container_pointer_type = void; using const_container_pointer_type = void;

/**

Constructor.

Parameters

name	Name of this aux variable.

The name -> auxid lookup is done here.

Parameters

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

The name -> auxid lookup is done here.

Parameters

auxid

ID for this auxiliary variable.

Will throw SG::ExcAuxTypeMismatch if the types don't match.

Parameters

name	Name of this aux variable.
clsname	The name of its associated class. May be blank.
flags	Optional flags qualifying the type. See AuxTypeRegistry.

The name -> auxid lookup is done here.

This is a version of Decorator, specialized for packed links.

This is like Accessor, except that it only `decorates' the container. What this means is that this object can operate on a const container and return a non-const reference. However, if the container is locked, this will only work if either this is a reference to a new variable, in which case it is marked as a decoration, or it is a reference to a variable already marked as a decoration.

Although the type argument is PackedLink<CONT>, the objects that this accessor produces are ElementLink<CONT> (returned by value rather than by const reference). The getDataSpan method will then produce a (writable) span over ElementLink<CONT>. (There are separate methods for returning spans over the PackedLink/DataLink arrays themselves.)

You might use this something like this:

// Only need to do this once.
using Cont_t = std::vector<int>;
static const SG::Decorator<SG::PackedLink<Cont_t> links ("links");
...
const DataVector<MyClass></em> v = ...;
const Myclass* m = v->at(2);
links (*m) = ElementLink<Cont_t> (...);
auto span = links.getDataSpan (*v);
span[2] = ElementLink<Cont_t> (...);

*/ template <class CONT, class ALLOC> class Decorator<PackedLink<CONT>, ALLOC> : public detail::LinkedVarAccessorBase { public: Aliases for the types we're dealing with. using Link_t = ElementLink<CONT>; using PLink_t = SG::PackedLink<CONT>; using DLink_t = DataLink<CONT>; using DLinkAlloc_t = typename std::allocator_traits<ALLOC>::template rebind_alloc<DLink_t>;

/ Spans over the objects that are actually stored. using const_PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, ALLOC>::const_span; using const_DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::const_span; using PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, ALLOC>::span; using DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::span;

/ Converter from PackedLink -> ElementLink. using ConstConverter_t = detail::PackedLinkConstConverter<CONT>;

/ Transform a span over PackedLink to a span over ElementLink. using const_span = CxxUtils::transform_view_with_at<const_PackedLink_span, ConstConverter_t>;

/ Writable proxy for PackedLink appearing like an ElementLink. using ELProxy = detail::ELProxyT<detail::ELProxyValBase<CONT> >;

/ Transform a non-const span of PackedLink to a range / of ElementLink proxies. using span = CxxUtils::transform_view_with_at<PackedLink_span, detail::ELProxyInSpanConverter<CONT> >;

/ Type the user sees. using element_type = Link_t;

/ Type referencing an item. using reference_type = ELProxy;

/ Type referencing an item. using const_reference_type = element_type;

/ A const reference type that can appear on the RHS of an assignment / to an application of a Decorator of this type. using rhs_const_reference_type = const Link_t&;

/ Not supported. using container_pointer_type = void; using const_container_pointer_type = void;

/**

Constructor.

Parameters

name	Name of this aux variable.

The name -> auxid lookup is done here.

Parameters

name	Name of this aux variable.

The name -> auxid lookup is done here.

Definition at line 576 of file AuxElement.h.

DecorHandleKeyArray

template<class T_Handle, class T_HandleKey, Gaudi::DataHandle::Mode MODE>

using SG::DecorHandleKeyArray = HandleKeyArray< T_Handle, T_HandleKey, MODE>

Definition at line 25 of file StoreGate/StoreGate/DecorHandleKeyArray.h.

element_type

using SG::element_type = elt_span

protected

Type the user sees.

Definition at line 434 of file PackedLinkDecorator.h.

ELSpanConverter

using SG::ELSpanConverter = detail::ELSpanConverter<CONT, VALLOC>

protected

Transform a span over vector of PackedLink to a span over span over ElementLink proxies.

Definition at line 428 of file PackedLinkDecorator.h.

elt_span

using SG::elt_span = detail::ELSpanProxy<CONT, VALLOC>

protected

Presents a vector of PackedLink as a range of ElementLink proxies.

Definition at line 423 of file PackedLinkDecorator.h.

getDataSourcePointerFunc_t

typedef IProxyDict ** SG::getDataSourcePointerFunc_t(const std::string &)

Definition at line 34 of file DataProxy.cxx.

guard_t

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

private

Definition at line 498 of file AuxStoreInternal.h.

iterator

typedef void SG::iterator

Definition at line 189 of file ArenaHeapAllocator.h.

JaggedVecVector

template<class T, class ALLOC = AuxAllocator_t<JaggedVecElt<T> >>

using SG::JaggedVecVector = JaggedVecVectorT<JaggedVecVectorHolder<T, ALLOC> >

Definition at line 226 of file JaggedVecVector.h.

maybe_thinning_error

typedef ExcElementNotFound SG::maybe_thinning_error

Backwards compatibility.

Definition at line 161 of file Control/AthLinks/AthLinks/exceptions.h.

mutex_t

typedef AthContainers_detail::mutex SG::mutex_t

private

Mutex used to synchronize modifications to the cache vector.

Mutex type for multithread synchronization.

Definition at line 497 of file AuxStoreInternal.h.

PackedLinkVector

template<class CONT, class ALLOC = AuxAllocator_t<PackedLink<CONT> >>

using SG::PackedLinkVector = PackedLinkVectorT<PackedLinkVectorHolder<CONT, ALLOC> >

Definition at line 267 of file PackedLinkVector.h.

PackedLinkVVector

template<class CONT, class VALLOC = AuxAllocator_t<PackedLink<CONT> >, class VELT = typename AuxDataTraits<PackedLink<CONT>, VALLOC >::vector_type, class ALLOC = AuxAllocator_t<VELT>>

using SG::PackedLinkVVector = PackedLinkVectorT<PackedLinkVVectorHolder<CONT, VALLOC, VELT, ALLOC> >

Definition at line 273 of file PackedLinkVector.h.

ProxyIterator

typedef ProxyMap::iterator SG::ProxyIterator

Definition at line 23 of file ProxyMap.h.

ProxyMap

typedef std::map<std::string, DataProxy*> SG::ProxyMap

Definition at line 22 of file ProxyMap.h.

ReadCondHandleKeyArray

template<class T>

using SG::ReadCondHandleKeyArray = HandleKeyArray<ReadCondHandle<T>, CondHandleDefault::Key<ReadCondHandleKey<T> >, Gaudi::DataHandle::Reader >

Definition at line 30 of file CondHandleKeyArray.h.

ReadDecorHandleKeyArray

template<class T, class S = float>

using SG::ReadDecorHandleKeyArray = DecorHandleKeyArray<ReadDecorHandle<T, S>, ReadDecorHandleKey<T>, Gaudi::DataHandle::Reader >

Definition at line 35 of file StoreGate/StoreGate/ReadDecorHandleKeyArray.h.

ReadHandleKeyArray

template<class T>

using SG::ReadHandleKeyArray = HandleKeyArray<ReadHandle<T>, ReadHandleKey<T>, Gaudi::DataHandle::Reader >

Definition at line 32 of file StoreGate/StoreGate/ReadHandleKeyArray.h.

reference_type

using SG::reference_type = elt_span

protected

Type referencing an item.

Definition at line 437 of file PackedLinkDecorator.h.

sgkey_t

typedef uint32_t SG::sgkey_t

Type used for hashed StoreGate key+CLID pairs.

Definition at line 32 of file sgkey_t.h.

SGKeyMap

template<class T>

using SG::SGKeyMap = std::unordered_map<sgkey_t, T>

A map using sgkey_t as a key.

Definition at line 93 of file sgkey_t.h.

SGKeySet

using SG::SGKeySet = std::unordered_set<sgkey_t>

A set of sgkey_t values.

Definition at line 97 of file sgkey_t.h.

SourceID

typedef std::string SG::SourceID

Definition at line 25 of file AthenaKernel/AthenaKernel/SourceID.h.

span

using SG::span

protected

Initial value:

 
CxxUtils::transform_view_with_at<PackedLinkVector_span, ELSpanConverter >

Definition at line 429 of file PackedLinkDecorator.h.

ThinningHandleKeyArray

template<class T>

using SG::ThinningHandleKeyArray = HandleKeyArray<ThinningHandle<T>,ThinningHandleKey<T>, Gaudi::DataHandle::Reader >

Definition at line 28 of file ThinningHandleKeyArray.h.

TypelessConstAccessor

using SG::TypelessConstAccessor = ConstAuxElement::TypelessConstAccessor

Definition at line 567 of file AuxElement.h.

WPtr

template<class T>

using SG::WPtr = T*

Definition at line 15 of file SGWPtr.h.

WriteCondHandleKeyArray

template<class T>

using SG::WriteCondHandleKeyArray = HandleKeyArray<WriteCondHandle<T>,CondHandleDefault::Key<WriteCondHandleKey<T> >, Gaudi::DataHandle::Writer >

Definition at line 33 of file CondHandleKeyArray.h.

WriteDecorHandleKeyArray

template<class T, class S = float>

using SG::WriteDecorHandleKeyArray = DecorHandleKeyArray<WriteDecorHandle<T, S>,WriteDecorHandleKey<T>, Gaudi::DataHandle::Writer >

Definition at line 35 of file StoreGate/StoreGate/WriteDecorHandleKeyArray.h.

WriteHandleKeyArray

template<class T>

using SG::WriteHandleKeyArray = HandleKeyArray<WriteHandle<T>,WriteHandleKey<T>, Gaudi::DataHandle::Writer >

Definition at line 32 of file WriteHandleKeyArray.h.

Enumeration Type Documentation

AllowEmptyEnum

enum SG::AllowEmptyEnum

Enumerator
AllowEmpty

Definition at line 26 of file StoreGate/StoreGate/VarHandleKey.h.

                    {
  AllowEmpty = 1
};

AuxVarFlags

enum SG::AuxVarFlags

Additional flags to qualify an auxiliary variable.

Enumerator
None	No special flags set.
Atomic	Mark that this variable should only be accessed atomically. If this is set, then the variable can be accessed only via AtomicDecorator. Be aware that this is not completely safe; it is still possible to have non-atomic accesses to the variable via either the implicit operations provided by this class or by explicit access to the value vector. Therefore, this is not recommended for general use. Contact core software before using this for new code.

Definition at line 58 of file AuxTypes.h.

                 {
  None   = 0x00,

  Atomic = 0x01,

  Linked = 0x02,
 
  // These flags control the behavior of findAuxID() but are not
  // stored with the variable.
  SkipNameCheck = 0x80,

  ATH_BITMASK
};

IndexTrackingPolicy

enum SG::IndexTrackingPolicy

Enumerator
DEFAULT_TRACK_INDICES	Default value. Set index tracking based on the ownership policy. If this container owns its elements, then track indices; otherwise do not.
ALWAYS_TRACK_INDICES	Always track indices, regardless of the setting of the ownership policy.
NEVER_TRACK_INDICES	Never track indices, regardless of the setting of the ownership policy.

Definition at line 37 of file IndexTrackingPolicy.h.

                         {
  DEFAULT_TRACK_INDICES,

  ALWAYS_TRACK_INDICES,

  NEVER_TRACK_INDICES
};

InvalidSlot

enum class SG::InvalidSlot

strong

Support of the invalid EventContext in SlotSpecificObj.

Enumerator
Enabled
Disabled

Definition at line 45 of file AthenaKernel/AthenaKernel/SlotSpecificObj.h.

{ Enabled, Disabled };

OwnershipPolicy

enum SG::OwnershipPolicy

Enumerator
OWN_ELEMENTS	this data object owns its elements
VIEW_ELEMENTS	this data object is a view, it does not own its elmts

Definition at line 16 of file OwnershipPolicy.h.

                       {
    OWN_ELEMENTS,  
    VIEW_ELEMENTS  
  };

PrivateStoreState

enum class SG::PrivateStoreState : uint8_t

strongprivate

The current private data state.

Enumerator
NO_PRIVATE
HAVE_PRIVATE
HAD_PRIVATE

Definition at line 131 of file IAuxElement.h.

  {
    NO_PRIVATE = 0,
    HAVE_PRIVATE = 1,
    HAD_PRIVATE = 2,
  };

Function Documentation

addAuxID()

void SG::addAuxID ( auxid_t auxid )

protected

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

Parameters

auxid

The auxid to add.

addVector()

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

protected

Explicitly add a vector to the store.

Parameters

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

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

Definition at line 147 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);
 
  return m_vecs[auxid].get();
}

allocate()

pointer SG::allocate

(

)

Allocate a new element.

The fast path of this will be completely inlined.

ArenaAllocatorBase::destroy_fcn< HepMC::GenEvent >()

template<>

void SG::ArenaAllocatorBase::destroy_fcn< HepMC::GenEvent > ( ArenaAllocatorBase::pointer p )

inline

Definition at line 66 of file HepMcDataPool.h.

  {
    HepMC::GenEvent* evt = reinterpret_cast<HepMC::GenEvent*>(p);
    evt->m_particle_barcodes.clear();
    evt->m_vertex_barcodes.clear();
    delete evt->m_pdf_info; evt->m_pdf_info = 0;
    evt->~GenEvent();
  }

ArenaAllocatorBase::destroy_fcn< HepMC::GenParticle >()

template<>

void SG::ArenaAllocatorBase::destroy_fcn< HepMC::GenParticle > ( ArenaAllocatorBase::pointer p )

inline

Definition at line 45 of file HepMcDataPool.h.

  {
    HepMC::GenParticle* part = reinterpret_cast<HepMC::GenParticle*>(p);
    part->m_production_vertex = 0;
    part->m_end_vertex = 0;
    part->~GenParticle();
  }

ArenaAllocatorBase::destroy_fcn< HepMC::GenVertex >()

template<>

void SG::ArenaAllocatorBase::destroy_fcn< HepMC::GenVertex > ( ArenaAllocatorBase::pointer p )

inline

Definition at line 55 of file HepMcDataPool.h.

  {
    HepMC::GenVertex* vtx = reinterpret_cast<HepMC::GenVertex*>(p);
    vtx->m_event = 0;
    vtx->m_particles_in.clear();
    vtx->m_particles_out.clear();
    vtx->~GenVertex();
  }

ArenaHeapAllocator() [1/3]

SG::ArenaHeapAllocator::ArenaHeapAllocator

(

ArenaHeapAllocator &&

other

)

Move constructor.

Definition at line 58 of file ArenaHeapAllocator.cxx.

    : ArenaBlockAllocatorBase (std::move (other)),
      m_freeptr (other.m_freeptr)
{
  // False positives
  // cppcheck-suppress useInitializationList
  other.m_freeptr = nullptr;
}

ArenaHeapAllocator() [2/3]

SG::ArenaHeapAllocator ( const ArenaHeapAllocator & )

delete

Don't allow copy construction or assignment.

ArenaHeapAllocator() [3/3]

SG::ArenaHeapAllocator::ArenaHeapAllocator

(

const Params &

params

)

Constructor.

Parameters

params

The parameters structure for this allocator. See ArenaAllocatorBase.h for the contents.

Definition at line 28 of file ArenaHeapAllocator.cxx.

  : ArenaBlockAllocatorBase (params),
    m_freeptr (nullptr)
{
  // Consistency check.
  assert (params.linkOffset + sizeof (pointer) <= params.eltSize);
}

ArenaPoolAllocator_iterator_increment() [1/2]

ArenaPoolAllocator::const_pointer SG::ArenaPoolAllocator_iterator_increment ( ArenaPoolAllocator::const_pointer base, const ArenaBlock *& block )

inline

Helper: common code for advancing an iterator.

Parameters

base	Element pointer.
block	Block pointer.

Definition at line 53 of file ArenaPoolAllocator.cxx.

{
  // If we haven't yet reached the start of this block, move the iterator
  // back one.
  if (base > block->index(0,0)) {
    return base - block->eltSize();
  }
 
  // Move to the previous block.
  block = block->link();
  if (block) {
    return block->index (block->size()-1, block->eltSize());
  }
  return nullptr;
}

ArenaPoolAllocator_iterator_increment() [2/2]

ArenaPoolAllocator::pointer SG::ArenaPoolAllocator_iterator_increment ( ArenaPoolAllocator::pointer base, ArenaBlock *& block )

inline

Helper: common code for advancing an iterator.

Parameters

base	Element pointer.
block	Block pointer.

Definition at line 28 of file ArenaPoolAllocator.cxx.

{
  // If we haven't yet reached the start of this block, move the iterator
  // back one.
  if (base > block->index(0,0)) {
    return base - block->eltSize();
  }
 
  // Move to the previous block.
  block = block->link();
  if (block) {
    return block->index (block->size()-1, block->eltSize());
  }
  return nullptr;
}

assign()

void SG::assign	(	const AuxElement &	other,
		bool	warnUnlocked = false )

Assignment.

Parameters

other	The object from which we're assigning.
warnUnlocked	If true, then warn when we skip unlocked decorations.

We don't copy container/index, as assignment doesn't change where this object is. However, if we have aux data, then we copy aux data if we're copying from an object that also has it; otherwise, if we're copying from an object with no aux data, then we clear ours.

asStorable() [1/3]

template<typename T>

DataObject * SG::asStorable

(

SG::DataObjectSharedPtr< T >

pObject

)

Definition at line 31 of file DataObjectSharedPtr.h.

                                                         {
  typedef typename DataBucketTrait<T>::type bucket_t;
  return new bucket_t (pObject.get());
}  

asStorable() [2/3]

template<typename T>

DataObject * SG::asStorable

(

std::unique_ptr< T >

pObject

)

Definition at line 159 of file StorableConversions.h.

                                                   {
    typedef typename std::remove_const<T>::type T_nc;
    typedef typename DataBucketTrait<T_nc>::type bucket_t;
    return new bucket_t (std::move(pObject));
  }  

asStorable() [3/3]

template<typename T>

DataObject * SG::asStorable

(

T *

pObject

)

Definition at line 153 of file StorableConversions.h.

                                     {
    typedef typename DataBucketTrait<T>::type bucket_t;
    return new bucket_t (pObject);
  }  

AthLinks_error()

void SG::AthLinks_error

(

)

For setting debugger breakpoints.

Definition at line 21 of file Control/AthLinks/src/exceptions.cxx.

{}

ATLAS_NOT_CONST_THREAD_SAFE()

IOpaqueAddress *TransientAddress::address SG::ATLAS_NOT_CONST_THREAD_SAFE ( ) const

inline

Retrieve IOpaqueAddress.

Definition at line 199 of file TransientAddress.h.

  {
    IOpaqueAddress* addr ATLAS_THREAD_SAFE = const_cast<IOpaqueAddress*> (m_address.get());
    return addr;
  }

ATLAS_NOT_THREAD_SAFE() [1/2]

void setDataProxyHolderInputRenameMap SG::ATLAS_NOT_THREAD_SAFE

(

const Athena::IInputRename::InputRenameRCU_t *

map

)

Set map used for performing input renaming in toTransient.

Parameters

map	The new map, or nullptr for no renmaing.

Definition at line 615 of file DataProxyHolder.cxx.

{
  s_inputRenameMap = map;
}

ATLAS_NOT_THREAD_SAFE() [2/2]

void setNSlotsHiveMgrName SG::ATLAS_NOT_THREAD_SAFE

(

const std::string &

s

)

Allow setting the name of the whiteboard service.

For testing.

Definition at line 35 of file SlotSpecificObj.cxx.

{
  getNSlots_hiveMgrName = s;
}

auxdata() [1/4]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::reference_type SG::auxdata

(

const std::string &

name

)

Fetch an aux data variable, as a non-const reference.

Parameters

name	Name of the aux variable.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

auxdata() [2/4]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type SG::auxdata

(

const std::string &

name

)

const

Fetch an aux data variable, as a const reference.

Parameters

name	Name of the aux variable.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor or ConstAccessor classes.

auxdata() [3/4]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::reference_type SG::auxdata	(	const std::string &	name,
		const std::string &	clsname )

Fetch an aux data variable, as a non-const reference.

Parameters

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

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

auxdata() [4/4]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type SG::auxdata	(	const std::string &	name,
		const std::string &	clsname ) const

Fetch an aux data variable, as a const reference.

Parameters

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

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor or ConstAccessor classes.

auxdataConst() [1/2]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type SG::auxdataConst

(

const std::string &

name

)

const

Fetch an aux data variable, as a const reference.

Parameters

name	Name of the aux variable.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the ConstAccessor class.

auxdataConst() [2/2]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Accessor< T, ALLOC >::const_reference_type SG::auxdataConst	(	const std::string &	name,
		const std::string &	clsname ) const

Fetch an aux data variable, as a const reference.

Parameters

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

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the ConstAccessor class.

auxdecor() [1/2]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Decorator< T, ALLOC >::reference_type SG::auxdecor

(

const std::string &

name

)

const

Fetch an aux decoration, as a non-const reference.

Parameters

name	Name of the aux variable.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

auxdecor() [2/2]

template<class T, class ALLOC = AuxAllocator_t<T>>

XAOD_AUXDATA_DEPRECATED Decorator< T, ALLOC >::reference_type SG::auxdecor	(	const std::string &	name,
		const std::string &	clsname ) const

Fetch an aux decoration, as a non-const reference.

Parameters

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

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

AuxElement() [1/2]

SG::AuxElement

(

const AuxElement &

other

)

Copy Constructor.

Parameters

other

Object being copied.

We do not copy the container/index — the new object is not yet in a container!

In the case of constructing an object with a private store, makePrivateStore will take care of copying the aux data.

AuxElement() [2/2]

SG::AuxElement	(	SG::AuxVectorData *	container,
		size_t	index )

Base class for elements of a container that can have aux data.

Classes that want to have associated auxiliary data should derive from this class. (It is also possible to use this class directly, if you want a container that only stores auxiliary data.)

The first thing that happens when you derive from AuxElement is that when an object is inserted into a DataVector, the vector will maintain information in the object telling were it is within the vector. For example:

DataVector<SG::AuxElement> v (2);
v[1] = new SG::AuxElement;
assert (v[1]->index() == 1);
assert (v[1]=>container() == &v);

As long as you don't use DataVector::stdcont or use unsafe casts, DataVector will correctly maintain this information.

When an object deriving from AuxElement is in a DataVector it may have auxiliary data associated with it; that is, named data objects of arbitrary type. The recommended way of accessing auxiliary data is through the Accessor and ConstAccessor classes, which cache the lookup between the aux data item name and its internal representation. The difference between these two is that ConstAccessor allows only const access to the element, while Accessor, which derives from it, allows non-const access as well. A given name must always have the same type, no matter where it is used (even across different classes); otherwise, an exception will be thrown. To help prevent conflicts between different classes, aux data item names may be optionally qualified with a class name. Here's an example of using ConstAccessor:

// Only need to do this once.
SG::ConstAccessor<int> vint1 ("myInt");
...
const Myclass* m = ...;
int x = vint1 (*m);

The auxdata methods can be used as a shortcut for this, but that's not recommended for anything for which performance is an issue.

You can also define getters/setters in your class:

class Myclass {
  ...
  int get_x() const
  { const static SG::ConstAccessor<int> acc ("x", "Myclass");
    return acc (*this); }
  int& get_x()
  { const static SG::Accessor<int> acc ("x", "Myclass");
    return acc (*this); }

In addition, one sometimes wants to add additional auxiliary data to an existing const container; for example, after a container has been retrieved from StoreGate. This is called `decoration', and is handled by the Decorator object, which is much like Accessor and ConstAccessor. The difference is that Decorator can take a const container and return a non-const, modifiable reference. If the container has been locked by calling StoreGateSvc::setConst, then this is allowed only if this is a new auxiliary item, in which case it is marked as a decoration, or if it is already marked as a decoration. This prevents changing existing variables in a locked container. An auxdecor method is also available, analogous to auxdata.

In addition to the above, the class TypelessConstAccessor is a non-templated class that allows access to auxiliary data items directly as a void *. This is useful for code which operates on auxiliary data generically; it shouldn't really be used in other contexts.

Normally, an object can have auxiliary data only when it is part of a container. But sometimes it is useful to be able to associate aux data with an object before it has been added to a container. You can enable this by creating a `private store' for the object with makePrivateStore. This can optionally take an argument from which aux data should be copied. (Using a private store adds overhead, which is why it is not enabled by default.) Example:

class Myclass : public SG::AuxElement { ... };
...
SG::Accessor<int> myint ("myint");
const Myclass* m = new Myclass;
m->makePrivateStore();
myint(*m) = 10;
DataVector<Myclass> v;
v.push_back(m);
assert (myint(v[0]) == 10);

When an object with a private store is added to a container, the aux data is copied to the container and the private store is released. However, the fact that we had a private store is remembered; if the object is later removed from the container, the private store will be remade, and the aux data will be copied back from the container to the private store. To explicitly release the private store (so that it won't come back automatically), call releasePrivateStore.

If you add makePrivateStore calls to the constructors of your class, then you should be able to treat aux data as if it were part of the object itself; the required copying will be handled automatically.

class Myclass : public SG::AuxElement
{
public:
  Myclass() { makePrivateStore(); }
  Myclass(const Myclass* other) { makePrivateStore(other); }

The SG::AuxElementComplete template class may be helpful in setting this up.

It is also possible to associate one of these objects with an external aux data store. This is the `standalone' mode. To do this, use the setStore methods, exactly as you would for a container that has aux data. setStore will throw an exception if the object is a member of a container or has a private store.

This class should not have any virtual methods (to avoid forcing derived classes to have a vtable). */ coverity[MISSING_MOVE_ASSIGNMENT] class AuxElement

: public ConstAuxElement

{ public: / Default constructor. AuxElement();

/**

Constructor with explicit container / index.

Parameters

container	Container of which this element will be a part.
index	Index of this element within the container.

This does not make any changes to aux data.

auxid()

SG::auxid_t SG::auxid

(

)

const

Return the aux id for this variable.

AuxStoreInternal() [1/2]

SG::AuxStoreInternal::AuxStoreInternal

(

bool

standalone = false

)

An auxiliary data store that holds data internally.

Constructor.

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

This class is an implementation of those interfaces that stores the data itself. This is suitable, for example, for transient auxiliary data. */ class AuxStoreInternal : public IAuxStore, public IAuxStoreIO { public: /**

Constructor.

Parameters

standalone	If true, then write this in standalone mode.
standalone	If true, then write this in standalone mode.

Definition at line 31 of file AuxStoreInternal.cxx.

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

AuxStoreInternal() [2/2]

SG::AuxStoreInternal::AuxStoreInternal

(

const AuxStoreInternal &

orig

)

Copy constructor.

Definition at line 51 of file AuxStoreInternal.cxx.

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

clearAux()

void SG::AuxElement::clearAux ( )

private

Clear all aux data associated with this element.

If this object has no associated store, this does nothing. If the associated aux data is const, this throws ExcConstAuxData.

Definition at line 567 of file AuxElement.cxx.

{
  if (!m_container) return;
  clearAuxHelper (*container(), index());
}

clearAuxHelper()

void SG::AuxElement::clearAuxHelper ( AuxVectorData & container, size_t index )

staticprivate

Clear all aux data associated with an element.

Parameters

container	Container of the element.
index	Index of this element within the container.

If the associated aux data is const, this throws ExcConstAuxData.

Definition at line 626 of file AuxElement.cxx.

{
  if (!container.hasStore()) return;
  if (!container.hasNonConstStore()) {
    throw SG::ExcConstAuxData ("clearAux", SG::null_auxid);
  }
 
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
  for (SG::auxid_t auxid : container.getWritableAuxIDs()) {
    r.clear (auxid, container, index, 1);
  }
}

clearCache()

void SG::clearCache

(

)

Clear the cached aux data pointers.

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

clearDecorations()

bool SG::clearDecorations ( ) const

override

Clear all decorations.

Erase all decorations from an associated 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.

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.

container()

SG::AuxVectorData * SG::container

(

)

const

Return the container holding this element.

contKeyFromKey()

std::string SG::contKeyFromKey

(

const std::string &

key

)

Extract the container part of key.

Parameters

key	The decoration handle key.

Given a key of the form CCC.DDD, returns the container part, CCC.

Definition at line 26 of file DecorKeyHelpers.cxx.

{
  std::string::size_type ipos = key.find ('.');
  if (ipos == std::string::npos)
    return key;
  return key.substr (0, ipos);
}

copyAux()

void SG::AuxElement::copyAux ( const ConstAuxElement & other, bool warnUnlocked = false )

private

Copy aux data from another object.

Parameters

other	The object from which to copy.
warnUnlocked	If true, then warn when we skip unlocked decorations.

If this object has no associated store, this does nothing. If the associated aux data is const, this throws ExcConstAuxData.

All aux data items from other are copied to this object. Any aux data items associated with this object that are not present in other are cleared. (If other has no aux data, then all aux data items for this object are cleared.)

Definition at line 587 of file AuxElement.cxx.

{
  if (!m_container) return;
  copyAuxHelper (*container(), index(), other, warnUnlocked);
}

copyAuxHelper()

void SG::AuxElement::copyAuxHelper ( AuxVectorData & container, size_t index, const ConstAuxElement & other, bool warnUnlocked )

staticprivate

Copy aux data from another object.

Parameters

container	Container of the element.
index	Index of this element within the container.
other	The object from which to copy.
warnUnlocked	If true, then warn when we skip unlocked decorations.

If the associated aux data is const, this throws ExcConstAuxData.

All aux data items from other are copied to this object. Any aux data items associated with this object that are not present in other are cleared. (If other has no aux data, then all aux data items for this object are cleared.)

Definition at line 654 of file AuxElement.cxx.

{
  if (!container.hasStore()) return;
  if (!container.hasNonConstStore())
    throw SG::ExcConstAuxData ("copyAux");
 
  const SG::AuxVectorData* ocont = other.container();
 
  if (!ocont || !ocont->hasStore()) {
    AuxElement::clearAuxHelper (container, index);
    return;
  }
 
  SG::auxid_set_t other_ids = ocont->getCopyIDs (warnUnlocked);
 
  size_t oindex = other.index();
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  for (SG::auxid_t auxid : other_ids) {
    if (!r.isLinked (auxid)) {
      r.copy (auxid, container, index, *ocont, oindex, 1);
    }
  }
 
  for (SG::auxid_t auxid : container.getWritableAuxIDs()) {
    if (!other_ids.test (auxid)) {
      r.clear (auxid, container, index, 1);
    }
  }
}

copyAuxStoreThinned()

void SG::copyAuxStoreThinned	(	const SG::IConstAuxStore &	orig,
		SG::IAuxStore &	copy,
		const SG::ThinningInfo *	info )

Helper to copy an aux store while applying thinning.

Parameters

orig	Source aux store from which to copy.
copy	Destination aux store to which to copy.
info	Thinning information for this object (or nullptr).

orig and copy are both auxiliary store objects. The data from orig will be copied to copy, with individual elements / variables removed according info.

copyThinned()

template<class CONTAINER>

std::unique_ptr< CONTAINER > SG::copyThinned	(	CONTAINER &	orig,
		const SG::ThinningInfo *	info )

Helper to copy an object while applying thinning.

Parameters

orig	The object to copy.
info	Thinning information for this object (or nullptr).

Returns a new copy of orig with elements removed according to the thinning defined in svc. Ownership of the new object is passed back to the caller.

The code here handles IAuxStore objects. (For a DataVector object, use copyThinnedConst.) Support for additional object types may be added by adding overloads for copyThinned1.

copyThinned1() [1/4]

template<class CONTAINER>

std::unique_ptr< const CONTAINER > SG::copyThinned1	(	const CONTAINER &	orig,
		const DataVector< typename CONTAINER::base_value_type > *	dummy,
		const SG::ThinningInfo *	info )

Helper to copy an object while applying thinning.

Parameters

orig	The object to copy.
dummy	Dummy argument for overload resolution.
info	Thinning information for this object (or nullptr).

This overload handles DataVector types. It returns a view container copy of orig, from which any thinned elements are removed.

copyThinned1() [2/4]

template<class CONTAINER>

std::unique_ptr< CONTAINER > SG::copyThinned1	(	const CONTAINER &	orig,
		const SG::IAuxStore *	dummy,
		const SG::ThinningInfo *	info )

Helper to copy an object while applying thinning.

Parameters

orig	The object to copy.
dummy	Dummy argument for overload resolution.
info	Thinning information for this object (or nullptr).

This overload handles IAuxStore types. It returns a new copy of the store, with any thinned elements removed.

copyThinned1() [3/4]

template<class CONTAINER>

std::unique_ptr< CONTAINER > SG::copyThinned1	(	const CONTAINER &	orig,
		const void *	dummy,
		const SG::ThinningInfo *	info )

Helper to copy an object while applying thinning.

Parameters

orig	The object to copy.
dummy	Dummy argument for overload resolution.
info	Thinning information for this object (or nullptr).

This is the generic version of copyThinned, which matches types for which there is not a more specific overload. It simply makes a copy of orig using the copy constructor.

copyThinned1() [4/4]

template<class CONTAINER>

std::unique_ptr< CONTAINER > SG::copyThinned1	(	CONTAINER &	orig,
		DataVector< typename CONTAINER::base_value_type > *	,
		const SG::ThinningInfo *	info )

Helper to copy an object while applying thinning.

Parameters

orig	The object to copy.
dummy	Dummy argument for overload resolution.
info	Thinning information for this object (or nullptr).

This overload handles DataVector types. It returns a view container copy of orig, from which any thinned elements are removed.

copyThinnedConst()

template<class CONTAINER>

std::unique_ptr< const CONTAINER > SG::copyThinnedConst	(	const CONTAINER &	orig,
		const SG::ThinningInfo *	info )

Helper to copy an object while applying thinning, const version.

Parameters

orig	The object to copy.
info	Thinning information for this object (or nullptr).

Returns a new copy of orig with elements removed according to the thinning defined in svc. Ownership of the new object is passed back to the caller.

The code here handles DataVector and IAuxStore objects. Support for additional object types may be added by adding overloads for copyThinned1.

DataProxy_cast() [1/3]

template<typename DATA>

DATA SG::DataProxy_cast

(

const DataProxy &

proxy

)

const ref version of the cast.

Exceptions

SG::ExcBadDataProxyCast.

Definition at line 64 of file DataProxy_cast.h.

{
  const DATA* result = SG::DataProxy_cast<DATA>(&proxy);
  if (!result) SG::throwExcBadDataProxyCast(proxy, typeid(DATA));
  return *result;
}

DataProxy_cast() [2/3]

template<typename DATA>

DATA * SG::DataProxy_cast

(

SG::DataProxy *

proxy

)

cast the proxy into the concrete data object it proxies

use optional>

Definition at line 53 of file DataProxy_cast.h.

                                         {
  typedef typename std::remove_const<DATA>::type DATA_nc;
  DataBucketTrait<DATA_nc>::init();
 
  return static_cast<DATA*>(DataProxy_cast (proxy, ClassID_traits<DATA>::ID(),
                                            &typeid(DATA_nc)));
}

DataProxy_cast() [3/3]

void * SG::DataProxy_cast	(	SG::DataProxy *	proxy,
		CLID	clid,
		const std::type_info *	tinfo = nullptr )

Try to get the pointer back from a DataProxy, converted to be of type clid.

Parameters

proxy	The DataProxy.
clid	The ID of the class to which to convert.

Only works if the held object is a DataBucket. Returns nullptr on failure,

Definition at line 633 of file DataProxy.cxx.

{
  if (nullptr == proxy || !proxy->isValid()) {
    return nullptr;
  }
 
  DataObject* pObject = proxy->accessData();
  if (nullptr == pObject) {
#ifndef NDEBUG
    MsgStream gLog(Athena::getMessageSvc(), "SG::DataProxy_cast");
    gLog << MSG::WARNING 
         << "this proxy " << MSG::hex << proxy
         << MSG::dec << " has a NULL data object ptr" << endmsg;
#endif
    return nullptr;
  }
 
  void* result = SG::Storable_cast (pObject, clid, tinfo, true, proxy, proxy->isConst());
  if (nullptr == result) { 
    //if result is null, probably CLID is neither the type the object was
    // stored with, nor it inherits from it. 
    // Before giving up let's check its transient CLIDs
    DataBucketBase* db(0);
    if (proxy->transientID(clid) &&
        nullptr != (db = dynamic_cast<DataBucketBase*>(pObject)) )
    {
      //it is a symlink after all. Let's hard cast and keep our fingers Xed
      // But first: if this is a non-const proxy, then the cast
      // may have failed because it needed to go via a copying conversion
      // that's not allowed for non-const objects.  So try the conversion
      // again as const; if that works, then don't do the hard cast.
      if (!proxy->isConst() &&
          SG::Storable_cast(pObject, clid, tinfo, true, proxy, true) != nullptr)
      {
#ifndef NDEBUG
        MsgStream gLog(Athena::getMessageSvc(), "SG::DataProxy_cast");
        gLog << MSG::WARNING 
             << "Request for a non-const object via copying conversion; "
             << "requested CLID = " << clid
             << ", proxy primary ID is " << proxy->clID() << endmsg   ;
#endif
      }
      else {
        // ok, hard cast.
        result = db->object();
      }
    }
    else { 
#ifndef NDEBUG
      MsgStream gLog(Athena::getMessageSvc(), "SG::DataProxy_cast");
      gLog << MSG::WARNING 
           << "Request for an invalid object; requested CLID = " 
           << clid
           << ", proxy primary ID is " << proxy->clID() << endmsg   ;
#endif
    } //try symlink
  } //result 0
 
  return result;
}

dataVectorAsELV()

template<class DV>

std::vector< ElementLink< DV > > SG::dataVectorAsELV	(	const DV &	v,
		IProxyDict *	store = 0 )

Helper to make a vector<EL> from a DataVector.

Given a DataVector, return a vector of ElementLink objects that reference the DataVector's elements. We can always do this if the DataVector owns its elements. However, if it is a view container, then the elements must derive from SG::AuxElement and must be part of some other container.

Definition at line 92 of file dataVectorAsELV.h.

{
  std::vector<ElementLink<DV> > ret;
  size_t sz = v.size();
  ret.reserve (sz);
 
  if (!store) store = SG::CurrentEventStore::store();
 
  if (v.ownPolicy() == SG::OWN_ELEMENTS) {
    // Could hoist the sgkey lookup.
    // But this will probably not be a common case, so don't do that
    // unless it's needed.
    for (size_t i = 0; i < sz; i++)
      ret.emplace_back (v, i, store);
  }
  else {
    dataVectorViewAsELV (typename AuxStore_traits<DV>::flag(), v, ret, store);
  }
  
  return ret;
}

dataVectorViewAsELV() [1/2]

template<class DV>

void SG::dataVectorViewAsELV	(	const std::false_type &	,
		const DV &	,
		std::vector< ElementLink< DV > > &	,
		IProxyDict *	)

Helper for dataVectorViewAsELV.

Don't call this directly.

Handle the case of a view vector with elements not deriving from AuxElement (just throw an exception).

Definition at line 71 of file dataVectorAsELV.h.

{
  throw SG::ExcDVToELV ("Element in view container does not derive from AuxElement.");
}

dataVectorViewAsELV() [2/2]

template<class DV>

void SG::dataVectorViewAsELV	(	const std::true_type &	,
		const DV &	v,
		std::vector< ElementLink< DV > > &	ret,
		IProxyDict *	store )

Helper for dataVectorViewAsELV.

Don't call this directly.

Handle the case of a view vector with elements deriving from AuxElement.

Definition at line 43 of file dataVectorAsELV.h.

{
  const DV* last_d = nullptr;
  const SG::AuxVectorData* last_b = nullptr;
  for (const typename DV::base_value_type* elt : v) {
    const SG::AuxVectorData* cont_b = elt->container();
    if (cont_b != last_b) {
      last_b = cont_b;
      last_d = dynamic_cast<const DV*>(cont_b);
    }
    if (!last_d)
      throw SG::ExcDVToELV ("Element not in a container");
    ret.emplace_back (*last_d, elt->index(), store);
  }
}

Decorator() [1/5]

SG::Decorator

(

const SG::auxid_t

auxid

)

Constructor taking an auxid directly.

Parameters

auxid

ID for this auxiliary variable.

Will throw SG::ExcAuxTypeMismatch if the types don't match.

Decorator() [2/5]

SG::Decorator ( const SG::auxid_t auxid, const SG::AuxVarFlags flags )

protected

Constructor taking an auxid directly.

Parameters

auxid	ID for this auxiliary variable.
flags	Optional flags qualifying the type. See AuxTypeRegistry.

Will throw SG::ExcAuxTypeMismatch if the types don't match.

Decorator() [3/5]

SG::Decorator

(

const std::string &

name

)

Helper class to provide type-safe access to aux data.

Constructor.

Helper class to provide type-safe access to aux data, specialized for PackedLink.

Helper class to provide type-safe access to aux data, specialized for JaggedVecElt.

This is like Accessor, except that it only `decorates' the container. What this means is that this object can operate on a const container and return a non-const reference. However, if the container is locked, this will only work if either this is a reference to a new variable, in which case it is marked as a decoration, or it is a reference to a variable already marked as a decoration.

This is written as a separate class in order to be able to cache the name -> auxid lookup.

You might use this something like this:

// Only need to do this once.
static const SG::Decorator<int> vint1 ("myInt");
...
const DataVector<MyClass></em> v = ...;
const Myclass* m = v->at(2);
vint1 (*m) = 123;

*/ template <class T, class ALLOC = AuxAllocator_t<T> > class Decorator { public: / Type referencing an item. using reference_type = typename AuxDataTraits<T, ALLOC>::reference_type;

/ Type referencing an item, as const reference. using const_reference_type = typename AuxDataTraits<T, ALLOC>::const_reference_type;

/ A const reference type that can appear on the RHS of an assignment / to an application of a Decorator of this type. using rhs_const_reference_type = const_reference_type;

/ Type the user sees. using element_type = typename AuxDataTraits<T, ALLOC>::element_type;

/ Pointer into the container holding this item. using container_pointer_type = typename AuxDataTraits<T, ALLOC>::container_pointer_type; using const_container_pointer_type = typename AuxDataTraits<T, ALLOC>::const_container_pointer_type;

/ A span over elements in the container. using span = typename AuxDataTraits<T, ALLOC>::span; using const_span = typename AuxDataTraits<T, ALLOC>::const_span;

/**

Constructor.

Parameters

name	Name of this aux variable.

The name -> auxid lookup is done here.

This is a version of Decorator, specialized for jagged vectors.

This is like Accessor, except that it only `decorates' the container. What this means is that this object can operate on a const container and return a non-const reference. However, if the container is locked, this will only work if either this is a reference to a new variable, in which case it is marked as a decoration, or it is a reference to a variable already marked as a decoration.

Although the type argument is JaggedVecElt<PAYLOAD_T>, the objects that this accessor produces are spans over elements of type PAYLOAD_T. The getDataSpan method will then produce a (writable) span over spans of PAYLOAD_T. (There are separate methods for returning spans over the element/payload arrays themselves.)

You might use this something like this:

// Only need to do this once.
using Cont_t = std::vector<int>;
static const SG::Decorator<SG::JaggedVecElt<Cont_t> jvec ("jvec");
...
const DataVector<MyClass></em> v = ...;
const Myclass* m = v->at(2);
jvec (*m)[3] = 10;
for (auto sp : jvec.getDataSpan (*v)) {
  for (int& x : sp) ...
}

*/ template <class PAYLOAD_T, class ALLOC> class Decorator<JaggedVecElt<PAYLOAD_T>, ALLOC> : public detail::LinkedVarAccessorBase { public: / Payload type. using Payload_t = PAYLOAD_T;

/ Allocator to use for the payload vector. using PayloadAlloc_t = typename std::allocator_traits<ALLOC>::template rebind_alloc<Payload_t>;

/ One element of the jagged vector. using Elt_t = SG::JaggedVecElt<PAYLOAD_T>;

/ Writable proxies for a jagged vector element: both a single proxy / and one used as part of a span. using JVecProxy = detail::JaggedVecProxyT<Payload_t, detail::JaggedVecProxyValBase>; using JVecProxyInSpan = detail::JaggedVecProxyT<Payload_t, detail::JaggedVecProxyRefBase>;

/ Converter from JaggedVecElt to a (writable) span. using Converter_t = detail::JaggedVecConverter<Payload_t>;

/ Converter from JaggedVecElt to a span. using ConstConverter_t = detail::JaggedVecConstConverter<Payload_t>;

/ Spans over the objects that are actually stored. using const_Elt_span = typename AuxDataTraits<JaggedVecElt<Payload_t>, ALLOC>::const_span; using const_Payload_span = typename AuxDataTraits<Payload_t, PayloadAlloc_t>::const_span; using Elt_span = typename AuxDataTraits<JaggedVecElt<Payload_t>, ALLOC>::span; using Payload_span = typename AuxDataTraits<Payload_t, PayloadAlloc_t>::span;

/ Spans over the entire jagged vector, both writable and not. using const_span = CxxUtils::transform_view_with_at<const_Elt_span, ConstConverter_t>; using span = CxxUtils::transform_view_with_at<Elt_span, Converter_t>;

/ Const span resulting from the conversion. using element_type = typename ConstConverter_t::element_type;

/ Type referencing an item (const). using const_reference_type = element_type;

/ The writable type we return. using reference_type = JVecProxy;

/ A const reference type that can appear on the RHS of an assignment / to an application of a Decorator of this type. using rhs_const_reference_type = std::span<const Payload_t>;

/ Not supported. using container_pointer_type = void; using const_container_pointer_type = void;

/**

Constructor.

Parameters

name	Name of this aux variable.

The name -> auxid lookup is done here.

This is a version of Decorator, specialized for packed links.

This is like Accessor, except that it only `decorates' the container. What this means is that this object can operate on a const container and return a non-const reference. However, if the container is locked, this will only work if either this is a reference to a new variable, in which case it is marked as a decoration, or it is a reference to a variable already marked as a decoration.

Although the type argument is PackedLink<CONT>, the objects that this accessor produces are ElementLink<CONT> (returned by value rather than by const reference). The getDataSpan method will then produce a (writable) span over ElementLink<CONT>. (There are separate methods for returning spans over the PackedLink/DataLink arrays themselves.)

You might use this something like this:

// Only need to do this once.
using Cont_t = std::vector<int>;
static const SG::Decorator<SG::PackedLink<Cont_t> links ("links");
...
const DataVector<MyClass></em> v = ...;
const Myclass* m = v->at(2);
links (*m) = ElementLink<Cont_t> (...);
auto span = links.getDataSpan (*v);
span[2] = ElementLink<Cont_t> (...);

*/ template <class CONT, class ALLOC> class Decorator<PackedLink<CONT>, ALLOC> : public detail::LinkedVarAccessorBase { public: Aliases for the types we're dealing with. using Link_t = ElementLink<CONT>; using PLink_t = SG::PackedLink<CONT>; using DLink_t = DataLink<CONT>; using DLinkAlloc_t = typename std::allocator_traits<ALLOC>::template rebind_alloc<DLink_t>;

/ Spans over the objects that are actually stored. using const_PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, ALLOC>::const_span; using const_DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::const_span; using PackedLink_span = typename AuxDataTraits<PackedLink<CONT>, ALLOC>::span; using DataLink_span = typename AuxDataTraits<DataLink<CONT>, DLinkAlloc_t>::span;

/ Converter from PackedLink -> ElementLink. using ConstConverter_t = detail::PackedLinkConstConverter<CONT>;

/ Transform a span over PackedLink to a span over ElementLink. using const_span = CxxUtils::transform_view_with_at<const_PackedLink_span, ConstConverter_t>;

/ Writable proxy for PackedLink appearing like an ElementLink. using ELProxy = detail::ELProxyT<detail::ELProxyValBase<CONT> >;

/ Transform a non-const span of PackedLink to a range / of ElementLink proxies. using span = CxxUtils::transform_view_with_at<PackedLink_span, detail::ELProxyInSpanConverter<CONT> >;

/ Type the user sees. using element_type = Link_t;

/ Type referencing an item. using reference_type = ELProxy;

/ Type referencing an item. using const_reference_type = element_type;

/ A const reference type that can appear on the RHS of an assignment / to an application of a Decorator of this type. using rhs_const_reference_type = const Link_t&;

/ Not supported. using container_pointer_type = void; using const_container_pointer_type = void;

/**

Constructor.

Parameters

name	Name of this aux variable.

The name -> auxid lookup is done here.

Parameters

name	Name of this aux variable.

The name -> auxid lookup is done here.

Decorator() [4/5]

SG::Decorator	(	const std::string &	name,
		const std::string &	clsname )

Constructor.

Parameters

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

The name -> auxid lookup is done here.

Decorator() [5/5]

SG::Decorator ( const std::string & name, const std::string & clsname, const SG::AuxVarFlags flags )

protected

Constructor.

Parameters

name	Name of this aux variable.
clsname	The name of its associated class. May be blank.
flags	Optional flags qualifying the type. See AuxTypeRegistry.

The name -> auxid lookup is done here.

decorKeyFromKey()

std::string SG::decorKeyFromKey	(	const std::string &	key,
		const std::string &	deflt )

Extract the decoration part of key.

Parameters

key	The decoration handle key.

Given a key of the form CCC.DDD, returns the decoration part, DDD or deflt if no decoration key is found.

Definition at line 42 of file DecorKeyHelpers.cxx.

{
  std::string::size_type ipos = key.find ('.');
  if (ipos == std::string::npos)
    return deflt;
  return key.substr (ipos+1, std::string::npos);
}

dumpBaseInfo()

void SG::dumpBaseInfo

(

)

Definition at line 736 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
  std::cout << "map:\n";
  if (BaseInfoBaseImpl::s_bi_by_ti) {
    std::vector<const std::type_info*> vv;
    for (const auto& x : *BaseInfoBaseImpl::s_bi_by_ti)
      vv.push_back (x.first);
    std::sort (vv.begin(), vv.end());
    for (const std::type_info* ti : vv)
    {
      const BaseInfoBase* bib = (*BaseInfoBaseImpl::s_bi_by_ti)[ti];
      std::cout << ti << " " << bib->clid() << " [" << System::typeinfoName (*ti)
                << "]\n";
    }
  }
 
  std::cout << "\ninitlist:\n";
  if (BaseInfoBaseImpl::s_init_list) {
    for (const auto& x : *BaseInfoBaseImpl::s_init_list)
      std::cout << x.first << " " << x.second << " ["
                << System::typeinfoName (*x.first) << "]\n";
  }
}

erase()

virtual void SG::erase ( )

finaloverridevirtual

Free all allocated elements and release memory back to the system.

All elements allocated are freed, and all allocated blocks of memory are released back to the system. destructor should be called on them if it was provided (preceded by clear if provided and mustClear was set).

excAuxTypeMismatch_format()

std::string SG::excAuxTypeMismatch_format	(	SG::auxid_t	auxid,
		const std::type_info &	new_type,
		const std::type_info &	old_type,
		const std::string &	new_alloc_type,
		const std::string &	old_alloc_type )

Helper: format exception error string.

Definition at line 170 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcAuxTypeMismatch: "
     << "Type mismatch for aux variable "
     << excFormatName (auxid)
     << "; old type is " << AthContainers_detail::typeinfoName (old_type)
     << " new type is "  << AthContainers_detail::typeinfoName (new_type);
  if (old_alloc_type != new_alloc_type)
  {
    os << ".  Old allocator type is " << old_alloc_type
       << " new allocator type is " << new_alloc_type;
  }
  return os.str();
}

excBadAuxVar_format()

std::string SG::excBadAuxVar_format

(

SG::auxid_t

auxid

)

Helper: format exception error string.

Definition at line 90 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcBadAuxVar: "
     << "Attempt to retrieve nonexistent aux data item "
     << excFormatName (auxid)
     << ".";
  return os.str();
}

excBadContext_format()

std::string SG::excBadContext_format	(	const EventContext &	ctx,
		const std::string &	key )

Helper: format exception error string.

Definition at line 373 of file Control/StoreGate/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcBadContext: Bad EventContext extension while building ReadCondHandle. "
     << "The EventContext extension is not "
     << (ctx.hasExtension() ? "of type Atlas::ExtendedEventContext" : "set")
     << " for key " << key << ".";
  return os.str();
}

excBadDataProxyCast_format()

std::string SG::excBadDataProxyCast_format	(	CLID	id,
		const std::type_info &	tid )

Helper: Format exception string.

Definition at line 23 of file Control/SGTools/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "Bad cast of DataProxy with CLID " << id
     << " to type " << System::typeinfoName (tid);
  return os.str();
}

excBadDecorElement_format()

std::string SG::excBadDecorElement_format	(	Gaudi::DataHandle::Mode	mode,
		CLID	clid,
		const std::string &	decorKey )

Helper: format exception error string.

Definition at line 451 of file Control/StoreGate/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcBadDecorElement: ";
  if (mode == Gaudi::DataHandle::Writer)
    os << "Write";
  else if (mode == Gaudi::DataHandle::Reader)
    os << "Read";
  else
    os << "???";
  os << "DecorHandle " << decorKey
     << "[" << clid << "]"
     << " given an element not in the requested container.";
  return os.str();
}

excBadForwardLink_format()

std::string SG::excBadForwardLink_format	(	size_t	index,
		size_t	size,
		const std::string &	name )

Helper: format exception error string.

Definition at line 122 of file Control/AthLinks/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcBadForwardLink: "
     << "ForwardIndexingPolicy: internal link state of '" << name << "' is invalid";
  if (index != static_cast<size_t>(-1)) {
    os << ": m_index = " << index
       << " is >= data container size = "
       << size << std::ends;
  } 
  return os.str();
}

excBadThinning_format()

std::string SG::excBadThinning_format	(	CLID	clid,
		const std::string &	key,
		SG::sgkey_t	sgkey )

Helper: format exception error string.

Definition at line 313 of file Control/AthLinks/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcBadThinning: "
     << "Bad thinning request "
     << "[" << clid << "/" << key << "] (" << sgkey << ")";
  return os.str();
}

excBadVarName_format()

std::string SG::excBadVarName_format

(

const std::string &

name

)

Helper: format exception error string.

Definition at line 646 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcBadVarName: "
     << "Bad name for auxiliary variable `" << name << "'. "
     << "Variable and class names must consist of only digits, letters, "
     << "and underscores, and cannot start with a digit.  "
     << "Variable names may not be empty, but class names may be.";
  return os.str();
}

excCLIDMismatch_format()

std::string SG::excCLIDMismatch_format	(	CLID	obj_clid,
		CLID	link_clid )

Helper: format exception error string.

Definition at line 53 of file Control/AthLinks/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcCLIDMismatch: "
     << "Attempt to set DataLink / ElementLink with CLID " << link_clid
     << " to object with CLID " << obj_clid;
  return os.str();
}

excConstAuxData_format()

std::string SG::excConstAuxData_format	(	const std::string &	op,
		SG::auxid_t	auxid )

Helper: format exception error string.

Definition at line 115 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcConstAuxData: "
     << "Non-const operation `" << op << "' performed on const aux data "
     << excFormatName (auxid)
     << ".";
  return os.str();
}

excConstObject_format()

std::string SG::excConstObject_format	(	CLID	clid,
		const std::string &	sgkey,
		const std::string &	storename )

Helper: format exception error string.

Definition at line 138 of file Control/StoreGate/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcConstObject: "
     << "Tried to retrieve non-const pointer to const object via VarHandleKey: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}

excConstStorable_format()

std::string SG::excConstStorable_format	(	CLID	clid,
		const std::string &	key,
		SG::sgkey_t	sgkey )

Helper: format exception error string.

Definition at line 283 of file Control/AthLinks/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcConstStorable: "
     << "Tried to retrieve const storable as a non-const pointer "
     << "[" << clid << "/" << key << "] (" << sgkey << ")";
  return os.str();
}

excDVToELV_format()

std::string SG::excDVToELV_format

(

const std::string &

detail

)

Helper: format exception error string.

Definition at line 365 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcDVToELV: "
     << "Can't convert DataVector to vector of ElementLinks: "
     << detail;
  return os.str();
}

excFlagMismatch_format()

std::string SG::excFlagMismatch_format	(	SG::auxid_t	auxid,
		const std::type_info &	type,
		SG::AuxVarFlags	existing_flags,
		SG::AuxVarFlags	requested_flags )

Helper: format exception error string.

Definition at line 484 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcFlagMismatch: "
     << "Flag mismatch for aux variable "
     << excFormatName (auxid)
     << " of type " << AthContainers_detail::typeinfoName (type)
     << " between existing " << excFormatFlags (existing_flags)
     << " and requested " << excFormatFlags (requested_flags) << " flags. "
     << "This may occur as a result of not using AtomicDecorator to access an atomic variable.";
  return os.str();
}

excFormatFlags()

std::string SG::excFormatFlags

(

SG::AuxVarFlags

flags

)

Helper: format flags.

Definition at line 469 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::string out;
  if (flags & SG::AuxVarFlags::Atomic)
    out = "atomic";
  if (flags & SG::AuxVarFlags::Linked) {
    if (!out.empty()) out += " ";
    out = "linked";
  }
 
  return "[" + out + "]";
}

excFormatName()

std::string SG::excFormatName

(

SG::auxid_t

auxid

)

Helper: format an aux data item name.

Definition at line 22 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  if (auxid != null_auxid) {
    SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
    os << "`" << r.getClassName (auxid);
    if (!os.str().empty())
      os << "::";
    os << r.getName (auxid);
    os << "' (" << auxid << ")";
  }
  else {
    os << "(null)";
  }
  return os.str();
}

excHandleInitError_format()

std::string SG::excHandleInitError_format	(	CLID	clid,
		const std::string &	sgkey,
		const std::string &	storename )

Helper: format exception error string.

Definition at line 68 of file Control/StoreGate/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcHandleInitError: "
     << "Error initializing VarHandle from VarHandleKey: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}

excInsertionInBaseClass_format()

std::string SG::excInsertionInBaseClass_format	(	const char *	op,
		const std::type_info &	base_type,
		const std::type_info &	complete_type )

Helper: format exception error string.

Definition at line 216 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcInsertionInBaseClass: "
     << "Attempted to do " << op
     << " on a " << AthContainers_detail::typeinfoName (base_type)
     << " base class of " << AthContainers_detail::typeinfoName (complete_type)
     << "; can only be done on the most-derived class.";
  return os.str();
}

excInvalidLink_format()

std::string SG::excInvalidLink_format	(	CLID	clid,
		const std::string &	key,
		SG::sgkey_t	sgkey )

Helper: format exception error string.

Definition at line 80 of file Control/AthLinks/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcInvalidLink: "
     << "Attempt to dereference invalid DataLink / ElementLink "
     << "[" << clid << "/" << key << "] (" << sgkey << ")";
  return os.str();
}

excInvalidThinningTarget_format()

std::string SG::excInvalidThinningTarget_format	(	unsigned int	clid,
		const std::string &	key )

Helper: format exception error string.

Definition at line 586 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcInvalidThinningTarget: "
     << "ThinningHandle target does not exist: "
     << clid << "/" << key;
  return os.str();
}

excJaggedVecOverlappingCopy_format()

std::string SG::excJaggedVecOverlappingCopy_format

(

)

Helper: format exception error string.

Definition at line 672 of file Control/AthContainers/Root/exceptions.cxx.

{
  return "SG::ExcJaggedVecOverlappingCopy: Overlapping copies not implemented for jagged vectors.  Talk to core software if this is an issue.";
}

excLinkMismatch_format()

std::string SG::excLinkMismatch_format	(	SG::auxid_t	auxid,
		const std::type_info &	type,
		SG::auxid_t	existing_linked_id,
		SG::auxid_t	requested_linked_id )

Helper: format exception error string.

Definition at line 521 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcLinkMismatch: "
     << "Linked variable mismatch for aux variable "
     << excFormatName (auxid)
     << " of type " << AthContainers_detail::typeinfoName (type)
     << " between existing " << excFormatName (existing_linked_id)
     << " and requested " << excFormatName (requested_linked_id) << " linked variables.";
  return os.str();
}

excNoAuxStore_format() [1/2]

std::string SG::excNoAuxStore_format

(

const char *

op

)

Helper: format exception error string.

Definition at line 56 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcNoAuxStore: "
     << "Operation attempted on container with no associated aux data store: ";
  os << op;
  return os.str();
}

excNoAuxStore_format() [2/2]

std::string SG::excNoAuxStore_format

(

SG::auxid_t

auxid

)

Helper: format exception error string.

Definition at line 44 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcNoAuxStore: "
     << "Requested aux data item "
     << excFormatName (auxid)
     << " but there is no associated aux data store.";
  return os.str();
}

excNoCondCont_format()

std::string SG::excNoCondCont_format	(	const std::string &	key,
		const std::string &	why )

Helper: format exception error string.

Definition at line 401 of file Control/StoreGate/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcNoCondCont: Can't retrieve CondCont from ReadCondHandle for key "
     << key << ". " << why;
  return os.str();
}

excNoLinkedVar_format()

std::string SG::excNoLinkedVar_format	(	SG::auxid_t	auxid,
		const std::type_info &	type )

Helper: format exception error string.

Definition at line 558 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcNoLinkedVar: "
     << "Linked variable not found for aux variable "
     << excFormatName (auxid)
     << " of type " << AthContainers_detail::typeinfoName (type);
  return os.str();
}

excNonConstHandleKey_format()

std::string SG::excNonConstHandleKey_format	(	CLID	clid,
		const std::string &	sgkey,
		const std::string &	storename )

Helper: format exception error string.

Definition at line 304 of file Control/StoreGate/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcNonConstHandleKey: "
     << "Attempt to get non-const VarHandleKey from non-owning VarHandle: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}

excNullReadHandle_format()

std::string SG::excNullReadHandle_format	(	CLID	clid,
		const std::string &	sgkey,
		const std::string &	storename )

Helper: format exception error string.

Definition at line 214 of file Control/StoreGate/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcNullReadHandle: "
     << "Dereference of read handle failed: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}

excNullUpdateHandle_format()

std::string SG::excNullUpdateHandle_format	(	CLID	clid,
		const std::string &	sgkey,
		const std::string &	storename )

Helper: format exception error string.

Definition at line 259 of file Control/StoreGate/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcNullUpdateHandle: "
     << "Dereference of update handle failed: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}

excNullWriteHandle_format()

std::string SG::excNullWriteHandle_format	(	CLID	clid,
		const std::string &	sgkey,
		const std::string &	storename )

Helper: format exception error string.

Definition at line 169 of file Control/StoreGate/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcNullWriteHandle: "
     << "Attempt to dereference write handle before record: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}

excPointerNotInSG_format()

std::string SG::excPointerNotInSG_format

(

const void *

pointer

)

Helper: format exception error string.

Definition at line 28 of file Control/AthLinks/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcPointerNotInSG: "
     << "The object referenced by a DataLink / ElementLink is not registered "
     << "in StoreGate: " << pointer << ".";
  return os.str();
}

excProtection_format()

std::string SG::excProtection_format

(

int

errnum

)

Definition at line 34 of file Control/AthAllocators/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcProtection: Attempt to change memory protection failed: ";
  char errbuf[256];
#ifdef _GNU_SOURCE
  os << strerror_r (errnum, errbuf, sizeof(errbuf));
#else
  strerror_r (errnum, errbuf, sizeof(errbuf));
  os << errbuf;
#endif
  return os.str();
}

excProxyCollision_format()

std::string SG::excProxyCollision_format	(	CLID	id,
		const std::string &	key,
		CLID	primary_id,
		const std::string &	primary_key )

Helper: Format exception string.

Definition at line 67 of file Control/SGTools/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "ExcProxyCollision: proxy collision for clid/key "
     << id << " / " << key
     << " (primary " << primary_id << " / " << primary_key << ").";
  return os.str();
}

excSgkeyCollision_format()

std::string SG::excSgkeyCollision_format	(	const std::string &	new_key,
		CLID	new_clid,
		const std::string &	old_key,
		CLID	old_clid,
		sgkey_t	sgkey )

Helper: Format exception string.

Definition at line 103 of file Control/SGTools/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "ExcSgkeyCollision: sgkey hash collision; new key: "
     << new_key << "/" << new_clid << " and existing key: "
     << old_key << "/" << old_clid << " both hash to " << sgkey;
  return os.str();
}

excStoreLocked_format() [1/2]

std::string SG::excStoreLocked_format

(

const char *

op

)

Helper: format exception error string.

Definition at line 262 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcStoreLocked: "
     << "Attempted to modify auxiliary data in a locked store: ";
  os << op;
  return os.str();
}

excStoreLocked_format() [2/2]

std::string SG::excStoreLocked_format

(

SG::auxid_t

auxid

)

Helper: format exception error string.

Definition at line 251 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcStoreLocked: "
     << "Attempted to modify auxiliary data in a locked store: ";
  os << excFormatName (auxid);
  return os.str();
}

excUninitKey_format()

std::string SG::excUninitKey_format	(	CLID	clid,
		const std::string &	sgkey,
		const std::string &	storename,
		const std::string &	holdername,
		const std::string &	htype )

Helper: format exception error string.

Definition at line 99 of file Control/StoreGate/src/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcUninitKey: "
     << "Error initializing " << htype << " from uninitialized " << htype << "Key: "
     << storename << "+" << sgkey << "[" << clid << "]; "
     << "keys should be initialized in your initialize().";
  if ( holdername.size() ) os << " Key held by " << holdername << ".";
  return os.str();
}

excUnknownAuxItem_format()

std::string SG::excUnknownAuxItem_format	(	const std::string &	name,
		const std::string &	clsname,
		const std::type_info *	typ )

Helper: format exception error string.

Definition at line 317 of file Control/AthContainers/Root/exceptions.cxx.

{
  std::ostringstream os;
  os << "SG::ExcUnknownAuxItem: "
     << "Unknown aux data item ";
  if (!clsname.empty())
    os << clsname << "::";
  os << name;
  if (typ)
    os << " (of type " << AthContainers_detail::typeinfoName (*typ) << ")";
  return os.str();
}

findInContainer() [1/4]

template<>

bool SG::findInContainer	(	const CaloCellContainer &	data,
		CaloCell const *const &	element,
		CaloCellContainer::size_type &	index )

Definition at line 676 of file CaloCellContainer.cxx.

{
  int ndx = data.findIndex (element->caloDDE()->calo_hash());
  if (ndx >= 0) {
    index = ndx;
    return true;
  }
  return false;
}

findInContainer() [2/4]

template<>

bool SG::findInContainer	(	const CaloCellContainer &	data,
		CaloCell const *const &	element,
		CaloCellContainer::size_type &	index )

Definition at line 676 of file CaloCellContainer.cxx.

{
  int ndx = data.findIndex (element->caloDDE()->calo_hash());
  if (ndx >= 0) {
    index = ndx;
    return true;
  }
  return false;
}

findInContainer() [3/4]

template<>

bool SG::findInContainer ( const CaloConstCellContainer & data, CaloCell const *const & element, CaloConstCellContainer::size_type & index )

inline

Definition at line 211 of file CaloConstCellContainer.h.

{
  return SG::findInContainer (*data.asDataVector(), element, index);
}

findInContainer() [4/4]

template<typename CONT, typename ELT>

bool SG::findInContainer	(	const CONT &	data,
		const ELT &	element,
		typename CONT::size_type &	index )

Find the index of an object within a container.

Parameters

	data	The container to search.
	element	The element for which to search.
[out]	index	The found index of the element.

Returns

true if the element was found; false otherwise.

By default, this function will do an exhaustive search through the container to find the element. However, this function may be specialized if this can be done more efficiently for some specific container.

Definition at line 37 of file findInContainer.h.

{
  typedef typename CONT::const_iterator const_iterator;
  const_iterator end = data.end();
  index = 0;
  for (const_iterator it = data.begin(); it != end; ++it) {
    if (*it == element) return true;
    ++index;
  }
  return false;
}

free()

void SG::free

(

pointer

p

)

Free an element.

Parameters

p	The element to be freed.

clear() will be called on the element at this point, if it has been defined.

fromStorable() [1/2]

void * SG::fromStorable	(	DataObject *	pDObj,
		CLID	clid,
		const std::type_info *	tinfo = nullptr,
		bool	quiet = false,
		IRegisterTransient *	irt = 0,
		bool	isConst = true )

Try to get the pointer back from a DataObject, converted to be of type clid.

Parameters

pDObj	The DataObject.
clid	The ID of the class to which to convert.
tinfo	type_info for the object being converted (optional).
quiet	If true, suppress warning messages.
irt	To be called if we make a new instance.
isConst	True if the object being converted is regarded as const.

Only works if the DataObject is a DataBucket. Returns 0 on failure,

Definition at line 35 of file StorableConversions.cxx.

{
  //check inputs
  if (0 == pDObj) {
    MsgStream gLog(Athena::getMessageSvc(), "SG::fromStorable");
    gLog << MSG::WARNING << "null input pointer " << endmsg;
    return nullptr;
  }
 
  // get T* from DataBucket:
  // All objects in the event store nowadays are instances
  // of DataBucket, so just do a static_cast.
  DataBucketBase* b = static_cast<DataBucketBase*>(pDObj);
  // Use BaseInfo information to convert pointers.
 
  void* ret = nullptr;
  if (tinfo)
    ret = b->cast (clid, *tinfo, irt, isConst);
  else
    ret = b->cast (clid, irt, isConst);
  if (!quiet && !ret) {
    const std::type_info* tid = CLIDRegistry::CLIDToTypeinfo (clid);
    MsgStream gLog(Athena::getMessageSvc(), "SG::fromStorable");
    gLog << MSG::WARNING 
         << "can't convert stored DataObject " << pDObj 
         << " to type ("
         << (tid ? System::typeinfoName (*tid) : "[unknown]")
         << ")\n Unless you are following a symlink,"
         << " it probably means you have a duplicate "
         << "CLID = "  << pDObj->clID() 
         << endmsg;
  }
  return ret;
}

fromStorable() [2/2]

template<typename T>

bool SG::fromStorable	(	DataObject *	pDObj,
		T *&	pTrans,
		bool	quiet = false,
		IRegisterTransient *	irt = 0,
		bool	isConst = true )

Definition at line 169 of file StorableConversions.h.

  {
    typedef typename std::remove_const<T>::type T_nc;
    DataBucketTrait<T_nc>::init();
 
    pTrans = static_cast<T*> (fromStorable (pDObj, ClassID_traits<T_nc>::ID(),
                                            &typeid(T_nc),
                                            quiet, irt, isConst));
    return pTrans != nullptr;
}

get() [1/5]

template<class T>

const T * SG::get	(	const ReadCondHandleKey< T > &	key,
		const EventContext &	ctx )

Convenience function to retrieve an object given a ReadCondHandleKey.

Parameters

key	The key to retrieve.
ctx	The event context.

Returns the object. Returns nullptr if the key is null or if there's an error.

Definition at line 282 of file ReadCondHandle.h.

  {
    if (key.key().empty()) return nullptr;
    try {
      ReadCondHandle<T> h (key, ctx);
      return h.cptr();
    }
    catch (SG::ExcNoCondCont&) {
      return nullptr;
    }
  }

get() [2/5]

template<class T>

const T * SG::get

(

const ReadHandleKey< T > &

key

)

Convenience function to retrieve an object given a ReadHandleKey.

Parameters

key	The key to retrieve.

Returns the object. Returns nullptr if the key is null or if there's an error.

get() [3/5]

template<class T>

const T * SG::get	(	const ReadHandleKey< T > &	key,
		const EventContext &	ctx )

Convenience function to retrieve an object given a ReadHandleKey.

Parameters

key	The key to retrieve.
ctx	The event context.

Returns the object. Returns nullptr if the key is null or if there's an error.

get() [4/5]

template<class T>

StatusCode SG::get	(	const T *&	ptr,
		const ReadCondHandleKey< T > &	key,
		const EventContext &	ctx )

Convenience function to retrieve an object given a ReadCondHandleKey.

Parameters

ptr	Pointer to the retrieved object.
key	The key to retrieve.

In case of error, sets ptr to nullptr and returns FAILURE. In case of an empty key, sets ptr to nullptr and returns SUCCESS.

Definition at line 305 of file ReadCondHandle.h.

  {
    ptr = get(key, ctx);
    return (ptr || key.empty()) ? StatusCode::SUCCESS : StatusCode::FAILURE;
  }

get() [5/5]

template<class T>

StatusCode SG::get	(	const T *&	ptr,
		const ReadHandleKey< T > &	key,
		const EventContext &	ctx )

Convenience function to retrieve an object given a ReadHandleKey.

Parameters

ptr	Pointer to the retrieved object.
key	The key to retrieve.

In case of error, sets ptr to nullptr and returns FAILURE. In case of an empty key, sets ptr to nullptr and returns SUCCESS.

getAuxIDs()

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

override

Return a set of identifiers for existing data items for this object.

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

If this object has a private or standalone store, then information from that will be returned. Otherwise, if this element is part of a container, then information for the container will be returned. Otherwise, return an empty set.

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

getClassIfDictionaryExists()

TClass * SG::getClassIfDictionaryExists

(

const std::string &

cname

)

Look up a TClass given a name.

Try to avoid autoparsing.

Parameters

cname

Name of the class to find.

Definition at line 27 of file getDynamicAuxID.cxx.

{
  if (TClass* cl = (TClass*)gROOT->GetListOfClasses()->FindObject(cname.c_str())) {
    if (cl->IsLoaded() && cl->HasDictionary()) return cl;
    return nullptr;
  }
 
  // The idea of calling GetClassSharedLibs was to test if a class was
  // listed in the rootmap file, so we could avoid autoparsing.
  // This worked with older versions of root 6.
  // But now root has started doing dynamic linking itself,
  // and GetClassSharedLibs will itself trigger autoparsing.
  // So currently, this test does more harm than good.
  // Still need to see if we can find a reliable way of failing
  // a TClass lookup rather than triggering autoparsing.
  //if (gInterpreter->GetClassSharedLibs (cname.c_str()))
  {
    TClass* cl = TClass::GetClass (cname.c_str());
    if (cl->HasDictionary())
      return cl;
  }
  return nullptr;
}

getConstStore()

const SG::IConstAuxStore * SG::getConstStore

(

)

const

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. This will fetch either a private or standalone store.

getCopyIDs() [1/2]

SG::auxid_set_t SG::getCopyIDs ( bool warnUnlocked = false ) const

overridevirtual

Return the set of variables to copy in a deep copy.

Parameters

warnUnlocked

If true, we warn about variables skipped on account of being decorations.

This is getAuxIDs()-getDecorIDs().

Parameters

warnUnlocked

If true, we warn about variables skipped on account of being decorations.

Usually this will be getAuxIDs()-getDecorIDs(), but can be different for special cases (such as shallow copies).

getCopyIDs() [2/2]

SG::auxid_set_t SG::getCopyIDs ( const SG::auxid_set_t & auxids, const SG::auxid_set_t & decors, bool warnUnlocked, std::span< const std::string > noWarn )

private

Compute the set of variables to copy in a deep copy.

Parameters

auxids	Set of all variables.
decors	Set of decorations.
warnUnlocked	If true, we warn about variables skipped on account of being decorations.
noWarn	Names of variables for which we should not issue such warnings.

Returns auxids - decors.

Definition at line 879 of file AuxStoreInternal.cxx.

{
  SG::auxid_set_t out = auxids;
#ifndef XAOD_STANDALONE
  if (warnUnlocked) {
    SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
    for (SG::auxid_t decor : decors) {
      if (out.test (decor)) {
        out.reset (decor);
        if (std::ranges::find (noWarn, r.getName (decor)) == noWarn.end()) {
          std::ostringstream ss;
          ss << "skipped unlocked decoration during copy " << r.getName(decor)
             << " (" << decor << ")";
          ATHCONTAINERS_WARNING("getCopyAuxIDs", ss.str());
        }
      }
    }
  }
  else
#endif
    out -= decors;
  return out;
}

getData() [1/2]

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

overridevirtual

Return the data vector for one aux data item.

Interface for const operations on an auxiliary store.

Parameters

auxid

The identifier of the desired aux data item.

Each aux data item is stored as a vector, with one entry per entry in the owning container. This returns a pointer to the start of the vector.

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

A DataVector may have auxiliary data associated with it. These data are kept in separate AuxStore objects; this defines the interface for const operations on such a store.

An AuxStore may store a number of different aux data items; these are identified by an integer of type auxid_t. Each item is stored as a vector with one entry per entry in the containing DataVector.

This interface provides methods for getting a const pointer to an existing vector of aux data items and for getting the set of existing aux data items.

In addition, sometimes we want to add additional auxiliary data to an existing, const container; this is called `decorating' it. For example, we retrieve a const container from StoreGate, run some algorithm on it, and attach additional data to the object that can be accessed by downstream algorithms or written to a file. To support this, we add the getDecoration operation, as well as lock and clearDecorations. When the object is first being filled, it is unlocked. It gets locked when StoreGateSvc::setConst is called on it. From then on, we can only create decorations. Calling clearDecorations will restore the state back to where it was when lock was called. (Be sure that the container's cache also gets cleared.)

getDecoration then works as follows:

• If the item doesn't exist, then it will be created. If the container is locked, then the new item will be marked as a decoration.
• If the item already exists, then we allow access only if either the container is not locked or the item is marked as a decoration. */ class IConstAuxStore { public: / Destructor. virtual ~IConstAuxStore() = default;

/**

Return the data vector for one aux data item.

Parameters

auxid

The identifier of the desired aux data item.

Each aux data item is stored as a vector, with one entry per entry in the owning container. This returns a pointer to the start of the vector.

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

getData() [2/2]

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

getDataArray()

const_container_pointer_type SG::getDataArray

(

const AuxVectorData &

container

)

const

Get a pointer to the start of the auxiliary data array.

Parameters

container

The container from which to fetch the variable.

getDataInternal()

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

protectedvirtual

Return the data vector for one aux data item.

Parameters

auxid	The identifier of the desired aux data item.
size	The current size of the container (in case the data item does not already exist).
capacity	The current capacity of the container (in case the data item does not already exist).
no_lock_check	If true, then skip the test for a locked container.

Each aux data item is stored as a vector, with one entry per entry in the owning container. This returns a pointer to the start of the vector.

If the data item does not exist, it should be created and initialized to default values. size and capacity give the size for the new aux data item vector.

Definition at line 763 of file AuxStoreInternal.cxx.

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

getDataLinkArray()

const DLink_t * SG::getDataLinkArray

(

const AuxVectorData &

container

)

const

Get a pointer to the start of the linked array of DataLinks.

Parameters

container

The container from which to fetch the variable.

getDataLinkDecorArray()

DLink_t * SG::getDataLinkDecorArray

(

const AuxVectorData &

container

)

const

Get a pointer to the start of the linked array of DataLinks, as a decoration.

Parameters

container

The container from which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

Parameters

container

The container from which to fetch the variable.

getDataLinkDecorSpan()

DataLink_span SG::getDataLinkDecorSpan

(

const AuxVectorData &

container

)

const

Get a span over the array of DataLinks, as a decoration.

Parameters

container

The container from which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getDataLinkSpan()

const_DataLink_span SG::getDataLinkSpan

(

const AuxVectorData &

container

)

const

Get a span over the array of DataLinks.

Parameters

container

The container from which to fetch the variable.

getDataSpan()

const_span SG::getDataSpan

(

const AuxVectorData &

container

)

const

Get a span over the auxiliary data array.

Get a span over spans of ElementLinks.

Get a span of ElementLinks.

Get a span over spans representing the jagged vector.

Parameters

container

The container from which to fetch the variable.

getDecoration()

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

overridevirtual

Return the data vector for one aux data decoration item.

Parameters

auxid	The identifier of the desired aux data item.
size	The current size of the container (in case the data item does not already exist).
capacity	The current capacity of the container (in case the data item does not already exist).

Each aux data item is stored as a vector, with one entry per entry in the owning container. This returns a pointer to the start of the vector.

If the data item does not exist, it then it will be created and initialized with default values. If the container is locked, then the new item will be marked as a decoration. size and capacity give the size for the new aux data item vector.

If the data item already exists, then we return it if either the container is not locked or the item is marked as a decoration. Otherwise we throw an exception.

getDecorationArray()

container_pointer_type SG::getDecorationArray

(

const AuxVectorData &

container

)

const

Get a pointer to the start of the auxiliary data array.

Parameters

container

The container from which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getDecorationSpan()

span SG::getDecorationSpan

(

const AuxVectorData &

container

)

const

Get a span over the auxiliary data array.

Get a span over spans of ElementLink proxies, as a decoration.

Get a span of ElementLink proxies, as a decoration.

Get a span over spans representing the jagged vector, as a decoration.

Parameters

container

The container from which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

Parameters

container

The container from which to fetch the variable.

The proxies may be converted to or assigned from ElementLink.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

Parameters

container

The container from which to fetch the variable.

The individual proxies may be converted to or assigned from ElementLink. Each element may also be assigned from a range of ElementLink, or converted to a vector of ElementLink.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getDecorIDs()

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

override

Return a set of identifiers for decorations for this object.

Return a set of identifiers for decorations in this store.

   If this object has a private or standalone store, then information
   from that will be returned.  Otherwise, if this element
   is part of a container, then information for the container
   will be returned.  Otherwise, return an empty set.

getDynamicAuxID()

SG::auxid_t SG::getDynamicAuxID	(	const std::type_info &	ti,
		const std::string &	name,
		const std::string &	elementTypeName,
		const std::string &	branchTypeName,
		bool	standalone,
		SG::auxid_t	linked_auxid )

Find the auxid for a dynamic branch.

Parameters

ti	Type of the auxiliary variable. Usually the type of the vector payload, but if standalone is true, then this is the type of the stored object.
name	Auxiliary variable name.
elementTypeName	Name of the type for one aux data element. Should be the same as branchTypeName if standalone is true.
branchTypeName	Name of the type for this branch.
standalone	True if this is a standalone object.

Definition at line 64 of file getDynamicAuxID.cxx.

{
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
  SG::auxid_t auxid = SG::null_auxid;
 
  SG::AuxVarFlags flags = SG::AuxVarFlags::SkipNameCheck;
  if (SG::AuxTypeRegistry::isLinkedName (name)) {
    flags |= SG::AuxVarFlags::Linked;
  }
 
  auxid = r.getAuxID (ti, name, "", flags, linked_auxid);
  if (auxid != SG::null_auxid) return auxid;
 
  // Be careful --- if we don't exactly match the name
  // in TClassTable, then we may trigger autoparsing.  Besides the
  // resource usage that implies, that can lead to crashes in dbg
  // builds due to cling bugs.
  std::string tn = elementTypeName;
  if (tn.starts_with("std::vector<"))
    tn.erase (0, 5);
  std::string fac_class_name = "SG::AuxTypeVectorFactory<" +
    tn + ",allocator<" + tn;
  if (fac_class_name[fac_class_name.size()-1] == '>')
    fac_class_name += ' ';
      fac_class_name += "> >";
  TClass* fac_class = getClassIfDictionaryExists (fac_class_name);
  if (fac_class)
  {
    TClass* base_class = getClassIfDictionaryExists ("SG::IAuxTypeVectorFactory");
    if (base_class) {
      int offs = fac_class->GetBaseClassOffset (base_class);
      if (offs >= 0) {
        void* fac_vp = fac_class->New();
        if (fac_vp) {
          SG::IAuxTypeVectorFactory* fac = reinterpret_cast<SG::IAuxTypeVectorFactory*> (reinterpret_cast<unsigned long>(fac_vp) + offs);
          const std::type_info* tiAlloc = fac->tiAlloc();
          r.addFactory (ti, *tiAlloc, std::unique_ptr<SG::IAuxTypeVectorFactory> (fac));
          auxid = r.getAuxID(*fac->tiAlloc(), ti, name, "", flags, linked_auxid);
        }
      }
    }
  }
 
  if (auxid == SG::null_auxid) {
    if (linked_auxid != SG::null_auxid) {
      errorcheck::ReportMessage msg (MSG::INFO, ERRORCHECK_ARGS, "getDynamicAuxID");
      msg << "dynamic ROOT vector factory not implemented for linked types: "
          << name << " " << branchTypeName << "\n";
      return SG::null_auxid;
    }
 
    std::string vec_name = branchTypeName;
    if (standalone) {
      vec_name = "std::vector<" + branchTypeName;
      if (vec_name[vec_name.size()-1] == '>')
        vec_name += " ";
      vec_name += ">";
    }
    TClass* vec_class = TClass::GetClass (vec_name.c_str());
 
    if (vec_class) {
      auto facp = std::make_unique<SG::RootAuxVectorFactory> (vec_class);
      std::string tiAllocName = facp->tiAllocName();
      (void)r.addFactory (ti, tiAllocName, std::move (facp));
      auxid = r.getAuxID(tiAllocName, ti, name, "", flags);
    }
  }
 
  return auxid;
}

getDynamicAuxIDs()

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

overridevirtual

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

getEltArray()

const Elt_t * SG::getEltArray

(

const AuxVectorData &

container

)

const

Get a pointer to the start of the array of JaggedVecElt objects.

Parameters

container

The container from which to fetch the variable.

getEltDecorArray()

Elt_t * SG::getEltDecorArray

(

const AuxVectorData &

container

)

const

Get a pointer to the start of the array of JaggedVecElt objects, as a decoration.

Parameters

container

The container from which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getEltDecorSpan()

Elt_span SG::getEltDecorSpan

(

const AuxVectorData &

container

)

const

Get a span over the array of JaggedVecElt objects, as a decoration.

Parameters

container

The container from which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getEltSpan()

const_Elt_span SG::getEltSpan

(

const AuxVectorData &

container

)

const

Get a span over the array of JaggedVecElt objects.

Parameters

container

The container from which to fetch the variable.

getIOData()

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

overridevirtual

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

Parameters

auxid

The identifier of the desired aux data item.

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

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

getIODataInternal()

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

protected

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

Parameters

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

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

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

Definition at line 478 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()

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

overridevirtual

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

Parameters

auxid

The identifier of the desired aux data item.

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

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

getNSlots()

size_t SG::getNSlots

(

)

Return the number of event slots.

Calls getNSlots_once the first time we're called and caches the result.

Definition at line 64 of file SlotSpecificObj.cxx.

{
  const static size_t nslots = getNSlots_once();
  return nslots;
}

getNSlots_once()

size_t SG::getNSlots_once

(

)

Return the number of event slots.

This accesses the IHiveWhiteBoard service to find the number of slots.

Definition at line 46 of file SlotSpecificObj.cxx.

{
  ServiceHandle<IInterface> svc (getNSlots_hiveMgrName, "getNSlots_once");
  if (!svc.retrieve().isSuccess())
    return 1;
  IHiveWhiteBoard* hivesvc = dynamic_cast<IHiveWhiteBoard*> (svc.get());
  if (!hivesvc) return 1;
  unsigned int nslots = hivesvc->getNumberOfStores();
  if (nslots < 1) return 1;
  return nslots;
}

getPackedLinkArray()

const PLink_t * SG::getPackedLinkArray

(

const AuxVectorData &

container

)

const

Get a pointer to the start of the array of PackedLinks.

Parameters

container

The container from which to fetch the variable.

getPackedLinkDecorArray()

PLink_t * SG::getPackedLinkDecorArray

(

const AuxVectorData &

container

)

const

Get a pointer to the start of the array of PackedLinks, as a decoration.

Parameters

container

The container from which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getPackedLinkDecorSpan() [1/3]

PackedLink_span SG::getPackedLinkDecorSpan

(

const AuxVectorData &

container

)

const

Get a span over the array of PackedLinks, as a decoration.

Parameters

container

The container from which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getPackedLinkDecorSpan() [2/3]

PackedLink_span SG::getPackedLinkDecorSpan ( const AuxVectorData & container, size_t index ) const

protected

Get a span over the vector of PackedLinks for a given element, as a decoration.

Parameters

container	The container from which to fetch the variable.
index	The index of the desired element.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getPackedLinkDecorSpan() [3/3]

template<IsConstAuxElement ELT>

PackedLink_span SG::getPackedLinkDecorSpan ( const ELT & e ) const

protected

Get a span over the vector of PackedLinks for a given element, as a decoration.

Parameters

e	The element for which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getPackedLinkSpan() [1/4]

PackedLink_span SG::getPackedLinkSpan ( AuxVectorData & container, size_t index ) const

protected

Get a span over the vector of PackedLinks for a given element.

Parameters

container	The container from which to fetch the variable.
index	The index of the desired element.

getPackedLinkSpan() [2/4]

const_PackedLink_span SG::getPackedLinkSpan

(

const AuxVectorData &

container

)

const

Get a span over the array of PackedLinks.

Parameters

container

The container from which to fetch the variable.

getPackedLinkSpan() [3/4]

const_PackedLink_span SG::getPackedLinkSpan ( const AuxVectorData & container, size_t index ) const

protected

Get a span over the vector of PackedLinks for a given element.

Parameters

container	The container from which to fetch the variable.
index	The index of the desired element.

getPackedLinkSpan() [4/4]

template<IsConstAuxElement ELT>

const_PackedLink_span SG::getPackedLinkSpan ( const ELT & e ) const

protected

Get a span over the vector of PackedLinks for a given element.

Parameters

e	The element for which to fetch the variable.

getPackedLinkVectorArray()

const VElt_t * SG::getPackedLinkVectorArray ( const AuxVectorData & container ) const

protected

Get a pointer to the start of the array of vectors of PackedLinks.

Parameters

container

The container from which to fetch the variable.

getPackedLinkVectorDecorArray()

VElt_t * SG::getPackedLinkVectorDecorArray ( const AuxVectorData & container ) const

protected

Get a pointer to the start of the array of vectors of PackedLinks, as a decoration.

Parameters

container

The container from which to fetch the variable.

getPackedLinkVectorDecorSpan()

PackedLinkVector_span SG::getPackedLinkVectorDecorSpan ( const AuxVectorData & container ) const

protected

Get a span over the vectors of PackedLinks, as a decoration.

Parameters

container

The container from which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getPackedLinkVectorSpan()

const_PackedLinkVector_span SG::getPackedLinkVectorSpan ( const AuxVectorData & container ) const

protected

Get a span over the vectors of PackedLinks.

Parameters

container

The container from which to fetch the variable.

getPayloadArray()

const Payload_t * SG::getPayloadArray

(

const AuxVectorData &

container

)

const

Get a pointer to the start of the payload array.

Parameters

container

The container from which to fetch the variable.

getPayloadDecorArray()

Payload_t * SG::getPayloadDecorArray

(

const AuxVectorData &

container

)

const

Get a pointer to the start of the payload array, as a decoration.

Parameters

container

The container from which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getPayloadDecorSpan()

Payload_span SG::getPayloadDecorSpan

(

const AuxVectorData &

container

)

const

Get a span over the payload vector, as a decoration.

Parameters

container

The container from which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

getPayloadSpan()

const_Payload_span SG::getPayloadSpan

(

const AuxVectorData &

container

)

const

Get a span over the payload vector.

Parameters

container

The container from which to fetch the variable.

getStore()

SG::IAuxStore * SG::getStore

(

)

const

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

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

getThinningCache() [1/2]

const SG::ThinningCache * SG::getThinningCache

(

)

Retrieve the current thinning cache from the current event context.

Returns nullptr if there is no current thinning cache.

Definition at line 41 of file getThinningCache.cxx.

{
  return getThinningCache (Gaudi::Hive::currentContext());
}

getThinningCache() [2/2]

const SG::ThinningCache * SG::getThinningCache

(

const EventContext &

ctx

)

Retrieve the current thinning cache from the event context.

ctx Event context.

Returns nullptr if there is no current thinning cache.

Definition at line 28 of file getThinningCache.cxx.

{
  if (ctx.hasExtension()) {
    return Atlas::getExtendedEventContext(ctx).thinningCache();
  }
  return nullptr;
}

getThinningDecision() [1/4]

const SG::ThinningDecisionBase * SG::getThinningDecision	(	const EventContext &	ctx,
		const sgkey_t	sgkey )

Retrieve the current thinning decision for sgkey.

ctx Event context.

Parameters

sgkey

SG hashed key to test.

Returns nullptr if there is no thinning for sgkey.

Definition at line 112 of file getThinningCache.cxx.

{
  if (const SG::ThinningCache* cache = getThinningCache (ctx)) {
    return cache->thinning (sgkey);
  }
  return nullptr;
}

getThinningDecision() [2/4]

const SG::ThinningDecisionBase * SG::getThinningDecision	(	const EventContext &	ctx,
		const std::string &	key )

Retrieve the current thinning decision for key.

ctx Event context.

Parameters

key	SG key to test.

Returns nullptr if there is no thinning for key.

Definition at line 83 of file getThinningCache.cxx.

{
  if (const SG::ThinningCache* cache = getThinningCache (ctx)) {
    return cache->thinning (key);
  }
  return nullptr;
}

getThinningDecision() [3/4]

const SG::ThinningDecisionBase * SG::getThinningDecision

(

const sgkey_t

sgkey

)

Retrieve the current thinning decision for sgkey.

Parameters

key	SG key to test.
sgkey	SG hashed key to test.

Returns nullptr if there is no thinning for sgkey.

Parameters

sgkey

SG hashed key to test.

Returns nullptr if there is no thinning for sgkey.

Definition at line 128 of file getThinningCache.cxx.

{
  return getThinningDecision (Gaudi::Hive::currentContext(), sgkey);
}

getThinningDecision() [4/4]

const SG::ThinningDecisionBase * SG::getThinningDecision

(

const std::string &

key

)

Retrieve the current thinning decision for key.

Parameters

key	SG key to test.

Returns nullptr if there is no thinning for key.

Definition at line 99 of file getThinningCache.cxx.

{
  return getThinningDecision (Gaudi::Hive::currentContext(), key);
}

getThinningInfo() [1/2]

const SG::ThinningInfo * SG::getThinningInfo	(	const EventContext &	ctx,
		const std::string &	key )

Retrieve the current thinning information for key.

ctx Event context.

Parameters

key	SG key to test.

Returns nullptr if there is no thinning for key.

Definition at line 54 of file getThinningCache.cxx.

{
  if (const SG::ThinningCache* cache = getThinningCache (ctx)) {
    return cache->thinningInfo (key);
  }
  return nullptr;
}

getThinningInfo() [2/2]

const SG::ThinningInfo * SG::getThinningInfo

(

const std::string &

key

)

Retrieve the current thinning information for key.

Parameters

key	SG key to test.

Returns nullptr if there is no thinning for key.

Definition at line 70 of file getThinningCache.cxx.

{
  return getThinningInfo (Gaudi::Hive::currentContext(), key);
}

getVector()

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

getVectorInternal_noLock()

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

privatevirtual

Implementation of getVectorInternal; no locking.

Definition at line 712 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()

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

overridevirtual

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

This should include only non-const identifiers.

hadPrivateData()

bool SG::hadPrivateData ( ) const

protected

True if this element had private data before it was added to its current container.

hasNonConstStore()

bool SG::hasNonConstStore

(

)

const

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

This will be true for either a private or standalone store.

hasStore()

bool SG::hasStore

(

)

const

Return true if this object has an associated store.

This will be true for either a private or standalone store.

havePrivateData()

bool SG::havePrivateData ( ) const

protected

True if this element currently has private data.

IAuxElement() [1/2]

SG::IAuxElement

(

)

Flag that a class may have auxiliary data associated with it.

This this class really exists only to flag that a class may have auxiliary data associated with it. SG::AuxElement derives from this, but one should use this class for tests rather than SG::AuxElement to avoid dependency issues.

This is an `interface' in the sense that it identifies a group of classes, but it defines no functionality itself. In fact, this class should not have a virtual table.

It turns out, however, that ROOT's branch splitting in TBranchElement can get confused in the case of an empty base class deriving from another base class. We can work around this by moving some of the data members from AuxElement here (even though they are transient). */ class IAuxElement { public: /**

Default constructor. For an element not in a container.

IAuxElement() [2/2]

SG::IAuxElement

(

size_t

index

)

Constructor.

Parameters

index

The index of this element in its container.

index()

size_t SG::index

(

)

const

Return the index of this element within its container.

insertMove()

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

overridevirtual

Move all elements from other to this store.

Parameters

pos	The starting index of the insertion.
other	Store from which to do the move.
ignore	Set of variables that should not be added to the store.

Let len be the size of other. The store will be increased in size by len elements, with the elements at pos being copied to pos+len. Then, for each auxiliary variable, the entire contents of that variable for other will be moved to this store at index pos. This will be done via move semantics if possible; otherwise, it will be done with a copy. Variables present in this store but not in other will have the corresponding elements default-initialized. Variables in other but not in this store will be added unless they are in ignore.

Returns true if it is known that none of the vectors' memory moved, false otherwise.

isAvailable() [1/3]

bool SG::isAvailable

(

const AuxVectorData &

c

)

const

Test to see if this variable exists in the store.

Parameters

c	The container in which to test the variable.

isAvailable() [2/3]

template<IsConstAuxElement ELT>

bool SG::isAvailable

(

const ELT &

e

)

const

Test to see if this variable exists in the store.

Parameters

e	An element of the container in which to test the variable.

isAvailable() [3/3]

template<class T, class ALLOC = AuxAllocator_t<T>>

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

Check if an aux variable is available for reading.

Parameters

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

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

isAvailableWritable() [1/3]

bool SG::isAvailableWritable

(

const AuxVectorData &

c

)

const

Test to see if this variable exists in the store and is writable.

Parameters

c	The container in which to test the variable.

isAvailableWritable() [2/3]

template<IsConstAuxElement ELT>

bool SG::isAvailableWritable

(

const ELT &

e

)

const

Test to see if this variable exists in the store and is writable.

Parameters

e	An element of the container in which to test the variable.

isAvailableWritable() [3/3]

template<class T, class ALLOC = AuxAllocator_t<T>>

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

Check if an aux variable is available for writing.

Parameters

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

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

isAvailableWritableAsDecoration()

template<class T, class ALLOC = AuxAllocator_t<T>>

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

Check if an aux 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.

This method has to translate from the aux data name to the internal representation each time it is called. Using this method inside of loops is discouraged; instead use the Accessor class.

isDecoration()

bool SG::isDecoration ( auxid_t auxid ) const

overridevirtual

Test if a particular variable is tagged as a decoration.

Parameters

auxid

The identifier of the desired aux data item.

link()

pointer & SG::link ( pointer p ) const

private

Return a reference to the link for an element.

Parameters

p	The element.

linkedVector()

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

overridevirtual

Return interface for a linked variable.

Parameters

auxid

The ID of the parent variable.

If auxid has a linked variable, then return the IAuxTypeVector describing it. Otherwise, return nullptr. May return nullptr unconditionally if this store does not support linked variables.

Definition at line 202 of file IConstAuxStore.h.

  { return nullptr; }

lock()

void SG::lock ( )

overridevirtual

Lock the container.

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

lockDecoration()

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

overridevirtual

Lock a decoration.

Parameters

auxid

Identifier of the decoration to lock.

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

lossyFloatCompress()

void SG::lossyFloatCompress	(	void *	dst,
		const std::size_t	idst,
		const std::size_t	n,
		const std::size_t	eltSize,
		const std::string &	typeName,
		const unsigned int	nmantissa )

Helper method to apply lossy float compression.

Parameters

dst	Pointer to the start of the vector's data
dst_index	Index of first element in vector
n	Number of elements to process.
eltSize	Element size for the auxid
typeName	Type name for the auxid
nmantissa	Compression level to be used for the auxid
dst	Pointer to the start of the vector's data
idst	Index of first element in vector
n	Number of elements to process.
eltSize	Element size for the auxid
typeName	Type name for the auxid
nmantissa	Compression level to be used for the auxid

Definition at line 213 of file copyAuxStoreThinned.cxx.

{
  // Check if there is anything to be done
  // Total number of explicit mantissa bits for a 32 bit float is 23
  // 0 is used to denote no compression should be applied to the variable
  static const unsigned int NMANTISSA_MAX = 23;
  if (nmantissa == 0 || nmantissa >= NMANTISSA_MAX) return;
 
  // Setup all possible compressors: done only once
  static const std::vector<CxxUtils::FloatCompressor> compressors = [] {
    std::vector<CxxUtils::FloatCompressor> result;
    result.reserve(NMANTISSA_MAX);
    for (std::size_t idx = 0; idx < NMANTISSA_MAX; ++idx)
      result.emplace_back(idx);
    return result;
  }();
 
  // Get the pointer to the memory
  char* eltPtr = reinterpret_cast<char*>(dst) + idst*eltSize;
 
  // This is where we apply in-place lossy float compression
  if(typeName == "float") {
    // cppcheck-suppress invalidPointerCast
    float* f = reinterpret_cast<float*> (eltPtr);
    for (size_t i = 0; i < n; i++) {
      *f = compressors[nmantissa].reduceFloatPrecision(*f);
      ++f;
    }
  } else if (typeName == "std::vector<float>"){
    for (size_t i = 0; i < n; i++) {
      std::vector<float> &vals = *(reinterpret_cast<std::vector<float>*>(eltPtr));
      for(auto &val: vals) {
        val = compressors[nmantissa].reduceFloatPrecision(val);
      }
      eltPtr += eltSize;
    }
  }
}

makeContDecorKey() [1/2]

std::string SG::makeContDecorKey	(	const std::string &	cont,
		const std::string &	decor )

Make a StoreGate key from container and decoration name.

Parameters

cont	The container handle key.
decor	The decoration handle key.

Given keys of the form "CCC" and "DDD", returns the full key, "CCC.DDD". If cont or decor is empty, returns the non-empty key (or an empty string).

Definition at line 59 of file DecorKeyHelpers.cxx.

{
  if (cont.empty()) return decor;
  if (decor.empty()) return cont;
  return cont + '.' + decor;
}

makeContDecorKey() [2/2]

std::string SG::makeContDecorKey	(	const VarHandleKey &	contKey,
		const std::string &	key )

Make a StoreGate key from container and decoration.

Parameters

contKey	The VarHandleKey of the container holding the decoration.
key	The decoration name.

Construct the StoreGate key from the associated container and the decoration name passed in key. If the latter also contains the container name, an exception will be raised. Returns an empty string if key is empty.

Definition at line 77 of file DecorKeyHelpers.cxx.

{
  if (key.empty() || key.ends_with ('+')) {
    return "";
  }
  if (key.find('.') != std::string::npos) {
    throw SG::ExcBadHandleKey(key + " (DecorHandleKey has been declared with a parent container. "
                              "Its value should not contain any container name.)");
  }
 
  // Note: VHK::fullKey().key() contains the store prefix, key() does not.
  return makeContDecorKey( contKey.fullKey().key(), key);
}

makeHandle() [1/18]

template<class T>

void SG::makeHandle

(

const ReadDecorHandleKey< T > &

key

)

These two signatures are to catch cases where the explicit template argument is omitted from the makeHandle call and give an error tailored to that.

Otherwise, the makeHandle call for ReadHandle would match, potentially giving a much more confusing error.

makeHandle() [2/18]

template<class D, class T>

ReadDecorHandle< T, D > SG::makeHandle

(

const ReadDecorHandleKey< T > &

key

)

Return a ReadDecorHandle referencing key.

Parameters

key	The key object holding the clid/key/store.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

The type of the decoration must be included as an explicit template parameter:

auto handle = SG::makeHandle<float> (key);

Note that D comes first in the argument list. It's given explicitly, while T is inferred from key.

makeHandle() [3/18]

template<class T>

void SG::makeHandle	(	const ReadDecorHandleKey< T > &	key,
		const EventContext &	ctx )

makeHandle() [4/18]

template<class D, class T>

ReadDecorHandle< T, D > SG::makeHandle	(	const ReadDecorHandleKey< T > &	key,
		const EventContext &	ctx )

Return a ReadDecorHandle referencing key for an explicit context.

Parameters

key	The key object holding the clid/key/store.
ctx	The event context.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

If the default event store has been requested, then the thread-specific store from the event context will be used.

The type of the decoration must be included as an explicit template parameter:

auto handle = SG::makeHandle<float> (key, ctx);

Note that D comes first in the argument list. It's given explicitly, while T is inferred from key.

makeHandle() [5/18]

template<class T>

ReadHandle< T > SG::makeHandle

(

const ReadHandleKey< T > &

key

)

Return a ReadHandle referencing key.

Parameters

key	The key object holding the clid/key/store.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

makeHandle() [6/18]

template<class T>

ReadHandle< T > SG::makeHandle	(	const ReadHandleKey< T > &	key,
		const EventContext &	ctx )

Return a ReadHandle referencing key for an explicit context.

Parameters

key	The key object holding the clid/key/store.
ctx	The event context.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

If the default event store has been requested, then the thread-specific store from the event context will be used.

makeHandle() [7/18]

template<class T>

SG::ReadCondHandle< T > SG::makeHandle	(	const SG::ReadCondHandleKey< T > &	key,
		const EventContext &	ctx = Gaudi::Hive::currentContext() )

Definition at line 269 of file ReadCondHandle.h.

                                                                                      {
     return SG::ReadCondHandle<T>(key, ctx);
  }

makeHandle() [8/18]

template<class T>

SG::WriteCondHandle< T > SG::makeHandle	(	const SG::WriteCondHandleKey< T > &	key,
		const EventContext &	ctx = Gaudi::Hive::currentContext() )

Definition at line 317 of file WriteCondHandle.h.

                                                                                       {
     return SG::WriteCondHandle<T>(key, ctx);
  }

makeHandle() [9/18]

template<class T>

ThinningHandle< T > SG::makeHandle

(

const ThinningHandleKey< T > &

key

)

Return a ThinningHandle referencing key.

Parameters

key	The key object holding the clid/key/store.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

Definition at line 135 of file ThinningHandle.h.

{
  return ThinningHandle<T> (key);
}

makeHandle() [10/18]

template<class T>

ThinningHandle< T > SG::makeHandle	(	const ThinningHandleKey< T > &	key,
		const EventContext &	ctx )

Return a ThinningHandle referencing key for an explicit context.

Parameters

key	The key object holding the clid/key/store.
ctx	The event context.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

If the default event store has been requested, then the thread-specific store from the event context will be used.

Definition at line 153 of file ThinningHandle.h.

{
  return ThinningHandle<T> (key, ctx);
}

makeHandle() [11/18]

template<class T>

UpdateHandle< T > SG::makeHandle

(

const UpdateHandleKey< T > &

key

)

Return an UpdateHandle referencing key.

Parameters

key	The key object holding the clid/key/store.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

makeHandle() [12/18]

template<class T>

UpdateHandle< T > SG::makeHandle	(	const UpdateHandleKey< T > &	key,
		const EventContext &	ctx )

Return an UpdateHandle referencing key for an explicit context.

Parameters

key	The key object holding the clid/key/store.
ctx	The event context.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

If the default event store has been requested, then the thread-specific store from the event context will be used.

makeHandle() [13/18]

template<class T>

void SG::makeHandle

(

const WriteDecorHandleKey< T > &

key

)

These two signatures are to catch cases where the explicit template argument is omitted from the makeHandle call and give an error tailored to that.

Otherwise, the makeHandle call for ReadHandle would match, potentially giving a much more confusing error.

makeHandle() [14/18]

template<class D, class T>

WriteDecorHandle< T, D > SG::makeHandle

(

const WriteDecorHandleKey< T > &

key

)

Return a WriteDecorHandle referencing key.

Parameters

key	The key object holding the clid/key/store.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

The type of the decoration must be included as an explicit template parameter:

auto handle = SG::makeHandle<float> (key);

Note that D comes first in the argument list. It's given explicitly, while T is inferred from key.

makeHandle() [15/18]

template<class T>

void SG::makeHandle	(	const WriteDecorHandleKey< T > &	key,
		const EventContext &	ctx )

makeHandle() [16/18]

template<class D, class T>

WriteDecorHandle< T, D > SG::makeHandle	(	const WriteDecorHandleKey< T > &	key,
		const EventContext &	ctx )

Return a WriteDecorHandle referencing key for an explicit context.

Parameters

key	The key object holding the clid/key/store.
ctx	The event context.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

If the default event store has been requested, then the thread-specific store from the event context will be used.

The type of the decoration must be included as an explicit template parameter:

auto handle = SG::makeHandle<float> (key, ctx);

Note that D comes first in the argument list. It's given explicitly, while T is inferred from key.

makeHandle() [17/18]

template<class T>

WriteHandle< T > SG::makeHandle

(

const WriteHandleKey< T > &

key

)

Return a WriteHandle referencing key.

Parameters

key	The key object holding the clid/key/store.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

makeHandle() [18/18]

template<class T>

WriteHandle< T > SG::makeHandle	(	const WriteHandleKey< T > &	key,
		const EventContext &	ctx )

Return a WriteHandle referencing key for an explicit context.

Parameters

key	The key object holding the clid/key/store.
ctx	The event context.

This will raise an exception if the StoreGate key is blank, or if the event store cannot be found.

If the default event store has been requested, then the thread-specific store from the event context will be used.

makePrivateStore() [1/3]

void SG::AuxElement::makePrivateStore

(

)

Create a new (empty) private store for this object.

ExcBadPrivateStore will be thrown if this object is already associated with a store.

Definition at line 192 of file AuxElement.cxx.

{
  if (m_container) {
    throw SG::ExcBadPrivateStore ("store already exists");
  }
 
  m_container = new SG::AuxElementPrivateData;
  IAuxElement::setIndex (0);
  IAuxElement::setHavePrivateData();
}

makePrivateStore() [2/3]

template<class U1>

void SG::makePrivateStore	(	const U1 &	other,
		bool	warnUnlocked = false )

Create a new private store for this object and copy aux data.

Parameters

other	The object from which aux data should be copied.
warnUnlocked	If true, then warn when we skip unlocked decorations.

ExcBadPrivateStore will be thrown if this object is already associated with a store.

If other is an object that has aux data, then those data will be copied; otherwise, nothing will be done.

makePrivateStore() [3/3]

template<class U1>

void SG::makePrivateStore	(	const U1 *	other,
		bool	warnUnlocked = false )

Create a new private store for this object and copy aux data.

Parameters

other	The object from which aux data should be copied.
warnUnlocked	If true, then warn when we skip unlocked decorations.

ExcBadPrivateStore will be thrown if this object is already associated with a store.

If other is an object that has aux data, then those data will be copied; otherwise, nothing will be done.

makePrivateStore1() [1/2]

void SG::AuxElement::makePrivateStore1 ( const AuxElement * other, bool warnUnlocked )

private

Create a new private store for this object and copy aux data.

Parameters

other	The object from which aux data should be copied.
warnUnlocked	If true, then warn when we skip unlocked decorations.

ExcBadPrivateStore will be thrown if this object is already associated with a store.

This overload handles the case where other does have aux data.

Definition at line 552 of file AuxElement.cxx.

{
  makePrivateStore();
  if (other)
    this->copyAux (*other, warnUnlocked);
}

makePrivateStore1() [2/2]

void SG::makePrivateStore1 ( const void * other, bool warnUnlocked )

private

Create a new private store for this object and copy aux data.

Parameters

other	The object from which aux data should be copied.
warnUnlocked	If true, then warn when we skip unlocked decorations.

ExcBadPrivateStore will be thrown if this object is already associated with a store.

This overload handles the case where other does not have aux data.

maybeUnprotect() [1/4]

template<class ALLOC>

void SG::maybeUnprotect

(

ALLOC &

)

Hook for unprotecting an arena.

Sometimes we need to ensure that an arena is unprotected before we start destroying an object that contains the arena. To do that without making assumptions about whether the arena supports an unprotect operation, call this function.

This is the generic version, which is a no-op. It will be specialized as appropriate for individual allocators.

Definition at line 32 of file maybeUnprotect.h.

{
}

maybeUnprotect() [2/4]

template<class T, class VETO>

void SG::maybeUnprotect

(

ArenaHeapSTLAllocator< T, VETO > &

a

)

Hook for unprotecting an arena.

Sometimes we need to ensure that an arena is unprotected before we start destroying an object that contains the arena. To do that without making assumptions about whether the arena supports an unprotect operation, call this function.

maybeUnprotect() [3/4]

template<class T, class VETO>

void SG::maybeUnprotect

(

ArenaPoolSTLAllocator< T, VETO > &

a

)

Hook for unprotecting an arena.

Sometimes we need to ensure that an arena is unprotected before we start destroying an object that contains the arena. To do that without making assumptions about whether the arena supports an unprotect operation, call this function.

maybeUnprotect() [4/4]

template<class T>

void SG::maybeUnprotect

(

ArenaSharedHeapSTLAllocator< T > &

a

)

Hook for unprotecting an arena.

Sometimes we need to ensure that an arena is unprotected before we start destroying an object that contains the arena. To do that without making assumptions about whether the arena supports an unprotect operation, call this function.

NO_SANITIZE_UNDEFINED()

void copyAuxStoreThinned SG::NO_SANITIZE_UNDEFINED	(	const SG::IConstAuxStore &	orig,
		SG::IAuxStore &	copy,
		const SG::ThinningInfo *	info )

Helper to copy an aux store while applying thinning.

Parameters

orig	Source aux store from which to copy.
copy	Destination aux store to which to copy.
info	Thinning information for this object (or nullptr).

orig and copy are both auxiliary store objects. The data from orig will be copied to copy, with individual elements / variables removed according info.

Definition at line 60 of file copyAuxStoreThinned.cxx.

{
  size_t size = orig.size();
  if (size == 0) {
    copy.resize(0);
    return;
  }
 
  const ThinningDecisionBase* dec = info ? info->m_decision : nullptr;
 
  size_t nremaining = dec ? dec->thinnedSize() : size;
  if( nremaining == 0) {
    copy.resize(0);
    return;
  }
 
  // Access the auxiliary type registry:
  SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
 
  // The auxiliary IDs that the original container has:
  SG::auxid_set_t auxids = orig.getAuxIDs();
  SG::auxid_set_t decors = orig.getDecorIDs();
 
  SG::auxid_set_t dyn_auxids;
  SG::auxid_set_t sel_auxids;
  if (const IAuxStoreIO* iio = dynamic_cast<const IAuxStoreIO*> (&orig)) {
    dyn_auxids = iio->getDynamicAuxIDs();
    sel_auxids = iio->getSelectedAuxIDs();
  }
 
  SG::auxid_set_t new_auxids = copy.getAuxIDs();
 
  copy.resize (nremaining);
 
  // Loop over all the variables of the original container:
  for (SG::auxid_t auxid : auxids) {
    // Skip null auxids (happens if we don't have the dictionary)
    if(auxid == SG::null_auxid) continue;
 
    // Skip linked variables (they'll be handled when we copy the variable
    // from which they're linked).
    if (r.isLinked (auxid)) continue;
 
    // Skip non-selected dynamic variables.
    // Handle variable vetoes requested via ThinningInfo.
    // We want to allow vetoing a variable if it's defined
    // as a dynamic variable in the source source, or if it doesn't
    // exist in the destination source (in which case it will be
    // dynamic there).  The latter case happens for example when
    // we save a static store object as the AuxContainerBaseClass
    // in order to make all variables dynamic.
    if (dyn_auxids.test(auxid) || !new_auxids.test(auxid)) {
      if (info) {
        if (info->vetoed(auxid)) continue;
      }
    }
 
    // Also check for a veto requested through the store selection interface.
    // (But this shouldn't really be used anymore.)
    if (dyn_auxids.test(auxid) && !sel_auxids.test(auxid)) {
      continue;
    }
 
    // Access the source variable:
    const void* src = orig.getData (auxid);
 
    if (!src) continue;
 
    // Warn if this is a decoration --- decorations should have been locked
    // by now, except for mcEventWeights, for which this is expected.
    if (decors.test (auxid) && r.getName (auxid) != "mcEventWeights") {
      std::ostringstream ss;
      ss << "unlocked decoration " << r.getName(auxid)
         << " (" << auxid << ") in object of type "
         << AthContainers_detail::typeinfoName (typeid (orig));
      ATHCONTAINERS_WARNING("copyAuxStoreThinned", ss.str());
    }
 
    // FIXME: Do this via proper interfaces.
    if (const IAuxStoreIO* iio = dynamic_cast<const IAuxStoreIO*> (&orig))
    {
      const std::type_info* typ = iio->getIOType (auxid);
      if (strstr (typ->name(), "PackedContainer") != nullptr) {
        // This cast gets a warning from the undefined behavior sanitizer
        // in gcc6.  Done like this deliberately for now, so suppress ubsan
        // checking for this function.
        const PackedParameters& parms =
          reinterpret_cast<const PackedContainer<int>* > (iio->getIOData (auxid))->parms();
        copy.setOption (auxid, AuxDataOption ("nbits", parms.nbits()));
        copy.setOption (auxid, AuxDataOption ("float", parms.isFloat()));
        copy.setOption (auxid, AuxDataOption ("signed", parms.isSigned()));
        copy.setOption (auxid, AuxDataOption ("rounding", parms.rounding()));
        copy.setOption (auxid, AuxDataOption ("nmantissa", parms.nmantissa()));
        copy.setOption (auxid, AuxDataOption ("scale", parms.scale()));
      }
    }
 
    // Get the element size, type name and compression info for the current auxid
    // This information is later passed to the helper function lossyFloatCompress
    const size_t eltSize{ r.getEltSize(auxid) };
    const std::string typeName{ r.getTypeName(auxid) };
    const unsigned int nmantissa{ info != nullptr ? info->compression(auxid) : 0 };
 
    // Create the target variable:
    void* dst = copy.getData (auxid, nremaining, nremaining);
 
    // Also create a linked variable if needed.
    SG::auxid_t linked_auxid = r.linkedVariable (auxid);
    if (linked_auxid != null_auxid) {
      const IAuxTypeVector* v = orig.linkedVector (auxid);
      if (v) {
        size_t sz = v->size();
        copy.getData (linked_auxid, 0, sz);
      }
    }
 
    TempInterface srciface (orig.size());
    srciface.setStore (&orig);
    TempInterface dstiface (copy.size());
    dstiface.setStore (&copy);
 
    // Copy over all elements.
    if (nremaining == size) {
      // No thinning.
      r.copyForOutput (auxid, dstiface, 0, srciface, 0, size);
    }
    else {
      // Some elements are thinned.
      for (std::size_t isrc = 0, idst = 0; isrc < size; ++isrc) {
        if (!dec || !dec->thinned(isrc)) {
          r.copyForOutput (auxid, dstiface, idst, srciface, isrc, 1);
          ++idst;
        }
      }
    }
    // Apply lossy float compression here (in-place).
    // Maybe it would be better to do this via the registry during copy.
    lossyFloatCompress(dst, 0, nremaining, eltSize, typeName, nmantissa);
  }
}

noPrivateData()

bool SG::noPrivateData ( ) const

protected

True if this element has no private data.

normalizedTypeinfoName()

std::string SG::normalizedTypeinfoName

(

const std::type_info &

info

)

Convert a type_info to a normalized string representation (matching the names used in the root dictionary).

Parameters

info	The type to convert.

The function AthContainer_detail::typeinfoName may be used to convert a C++ type_info to a string representing the name of the class; this handles platform-dependent details such as performing demangling.

However, the name you get as a result of this does not necessarily match the name by which the class is known in the ROOT dictionary. In particular, defaulted template arguments for STL containers and DataVector are suppressed in the dictionary. So, for example, for a vector class typeinfoName may produce std::vector<int, std::allocator<T> >, while in the dictionary it is known as std::vector<int>. Using normalizedTypeinfoName instead will transform the names to match what's in the dictionary. This function will also cache the typeinfo -> string conversions.

Definition at line 120 of file normalizedTypeinfoName.cxx.

{
  // Maintain a cache of mappings, protected with an ordinary mutex.
  // We originally did this with an upgrading mutex.
  // However, these mutexes have been observed to have considerable overhead,
  // so are probably not worthwhile if the read critical section is short.
  // If this lock becomes a performance issue, consider a concurrent hashmap
  // or rcu-style solution.
  typedef std::unordered_map<const std::type_info*, std::string> typemap_t;
  static typemap_t normalizedTypemap ATLAS_THREAD_SAFE;
  typedef AthContainers_detail::mutex mutex_t;
  static mutex_t normalizedTypemapMutex;
  AthContainers_detail::lock_guard<mutex_t> lock (normalizedTypemapMutex);
 
  // Test to see if we already have the mapping.
  typemap_t::iterator it = normalizedTypemap.find (&info);
  if (it != normalizedTypemap.end()) {
    return it->second;
  }
 
  // Didn't find it.  Apply the rules.
  static const CxxUtils::ClassName::Rules normalizeRules = makeRules();
  std::string tiname = AthContainers_detail::typeinfoName (info);
  std::string normalizedName = normalizeRules.apply (tiname);
 
  // Remember this mapping.
  normalizedTypemap[&info] = normalizedName;
  return normalizedName;
}

noToTransient()

template<class T>

bool SG::noToTransient ( )

constexpr

Helper to test if T::noToTransient exists as a typedef.

Definition at line 84 of file ToTransient.h.

{ return noToTransient1<ToTransient<T> > (123); }

noToTransient1() [1/2]

template<class T>

bool SG::noToTransient1 ( int , typename T::noToTransient = typename T::noToTransient() )

constexpr

Definition at line 76 of file ToTransient.h.

{ return true; }

noToTransient1() [2/2]

template<class T, class U>

bool SG::noToTransient1 ( U )

constexpr

Definition at line 73 of file ToTransient.h.

{ return false; }

null_arena_deleter()

void SG::null_arena_deleter

(

ArenaBase *

)

Definition at line 28 of file ArenaHeader.cxx.

{}

operator!=()

bool SG::operator!=	(	const VarHandleBase &	l,
		const VarHandleBase &	r )

Inequality comparison.

Definition at line 129 of file AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx.

  {
    return !(l==r);
  }

operator()() [1/4]

elt_span SG::operator()	(	const AuxVectorData &	container,
		size_t	index ) const

Fetch the variable for one element, as a non-const reference.

Fetch the variable for one element.

Parameters

container	The container from which to fetch the variable.
index	The index of the desired element.

This allows retrieving aux data by container / index. Looping over the index via this method will be faster then looping over the elements of the container.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

Parameters

container	The container from which to fetch the variable.
index	The index of the desired element.

This allows retrieving aux data by container / index.

Will return a proxy object, which will allow treating this jagged vector element as a vector.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

Parameters

container	The container from which to fetch the variable.
index	The index of the desired element.

This allows retrieving aux data by container / index.

Will return an ElementLink proxy, which may be converted to or assigned from an ElementLink.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

Parameters

container	The container from which to fetch the variable.
index	The index of the desired element.

This allows retrieving aux data by container / index.

This will return a range of ElementLink proxies. These proxies may be converted to or assigned from ElementLink.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

operator()() [2/4]

template<IsConstAuxElement ELT>

reference_type SG::operator()

(

const ELT &

e

)

const

Fetch the variable for one element, as a non-const reference.

Parameters

e	The element for which to fetch the variable.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

Parameters

e	The element for which to fetch the variable.

Will return a proxy object, which will allow treating this jagged vector element as a vector.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

operator()() [3/4]

template<IsConstAuxElement ELT>

elt_span SG::operator() ( const ELT & e ) const

protected

Fetch the variable for one element.

Parameters

e	The element for which to fetch the variable.

This will return a range of ElementLink proxies. These proxies may be converted to or assigned from ElementLink.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

operator()() [4/4]

template<IsConstAuxElement ELT>

ELProxy SG::operator()

(

const ELT &

e

)

const

Fetch the variable for one element.

Parameters

e	The element for which to fetch the variable.

Will return an ElementLink proxy, which may be converted to or assigned from an ElementLink.

If the container is locked, this will allow fetching only variables that do not yet exist (in which case they will be marked as decorations) or variables already marked as decorations.

operator<<() [1/4]

std::ostream & SG::operator<<	(	std::ostream &	os,
		const ArenaAllocatorBase::Stats &	stats )

Format a complete statistics structure.

Parameters

os	The stream to which to write.
stats	The statistics structure to write.

Definition at line 104 of file ArenaAllocatorBase.cxx.

{
  os << stats.elts << " " << stats.bytes << " " << stats.blocks;
  return os;
}

operator<<() [2/4]

std::ostream & SG::operator<<	(	std::ostream &	os,
		const ArenaAllocatorBase::Stats::Stat &	stat )

Format a statistic structure.

Parameters

os	The stream to which to write.
stat	The statistic structure to write.

Definition at line 61 of file ArenaAllocatorBase.cxx.

{
  os << std::setw(7) << stat.inuse << "/"
     << std::setw(7) << stat.free << "/" 
     << std::setw(7) << stat.total;
  return os;
}

operator<<() [3/4]

std::ostream & SG::operator<< ( std::ostream & ost, const SG::VersionedKey & k )

inline

Definition at line 116 of file SGVersionedKey.h.

                                                                      {
    return ost << k.rawVersionKey();
    //  return ost.write(k.rawVersionKey(), strlen(k.rawVersionKey()));
  }

operator<<() [4/4]

std::ostream & SG::operator<<	(	std::ostream &	out,
		const VarHandleBase &	o )

Return the name of the store holding the object we are proxying.

Output stream.

Output stream.

Parameters

out	Stream to which to write.
o	Object to write.
out	Stream to which to write.
o	Object to write.

Definition at line 107 of file AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx.

  {
    out << "VarHandleBase @" << &o
        // << " store=" <<o.store()
        << ", key=" <<o.key();
    return out;
  }

operator=() [1/4]

ArenaHeapAllocator & SG::operator=

(

ArenaHeapAllocator &&

other

)

Move assignment.

operator=() [2/4]

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

delete

operator=() [3/4]

AuxElement & SG::operator=

(

const AuxElement &

other

)

Assignment.

Parameters

other

The object from which we're assigning.

We don't copy container/index, as assignment doesn't change where this object is. However, if we have aux data, then we copy aux data if we're copying from an object that also has it; otherwise, if we're copying from an object with no aux data, then we clear ours.

operator=() [4/4]

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

delete

Don't allow assignment.

operator==()

bool SG::operator==	(	const VarHandleBase &	l,
		const VarHandleBase &	r )

Equality comparison.

Definition at line 119 of file AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx.

  {
    return (l.name() == r.name());//  &&
            // l.store() == r.store());
  }

ReadCondHandleNotFound()

void SG::ReadCondHandleNotFound	(	const CondContBase &	cc,
		const EventIDBase &	eid,
		const std::string &	key )

Report a conditions container lookup failure.

Parameters

cc	The conditions container.
eid	The time for which to search.
The	key corresponding to the conditions container.

Definition at line 23 of file ReadCondHandle.cxx.

{
  std::ostringstream ost;
  cc.list(ost);
  MsgStream msg(Athena::getMessageSvc(), "ReadCondHandle");
  msg << MSG::ERROR 
      << "ReadCondHandle::retrieve() could not find EventTime " 
      << eid  << " for key " << key << "\n"
      << ost.str()
      << endmsg;
}

readPackedParameters()

SG::PackedParameters SG::readPackedParameters ( TBuffer & b )

inline

Read a set of packed parameters from a buffer.

Parameters

b	Buffer from which to write.

Definition at line 47 of file PackedContainerStreamer.cxx.

                                                      {
   uint8_t nbits;
   b >> nbits;
 
   uint8_t flags;
   b >> flags;
 
   SG::PackedParameters parms (nbits, flags);
   if (parms.isFloat()) {
      uint8_t nmantissa;
      b >> nmantissa;
      parms.setNmantissa (nmantissa);
      if (parms.hasScale()) {
         float scale;
         b >> scale;
         parms.setScale (scale);
      }
   }
   return parms;
}

refill()

pointer SG::refill ( )

private

Add more free elements to the pool, and allocate a new element.

releasePrivateStore()

void SG::AuxElement::releasePrivateStore

(

)

Release and free any private store associated with this object.

ExcBadPrivateStore will be thrown if this object does not have a private store.

Definition at line 210 of file AuxElement.cxx.

{
  if (hadPrivateData()) {
    // We had a private store, but it was released because this object
    // was added to a container.  Just forget about it.
    IAuxElement::setNoPrivateData();
    return;
  }
 
  if (!havePrivateData() ||
      !m_container ||
      typeid(*m_container) != typeid(AuxElementPrivateData))
  {
    throw SG::ExcBadPrivateStore ("no private store exists");
  }
 
  IAuxElement::setIndex (0);
  IAuxElement::setNoPrivateData();
  delete m_container;
  m_container = 0;
}

releasePrivateStoreForDtor()

void SG::releasePrivateStoreForDtor ( )

private

Out-of-line portion of destructor.

Delete a private store if we have one.

removeContFromDecorKey()

void SG::removeContFromDecorKey	(	const VarHandleKey &	contKey,
		std::string &	key )

Remove container name from decoration key.

Parameters

contKey	The VarHandleKey of the container holding the decoration.
key	The decoration name to be modified.

Given a key of the form SG+CCC.DDD, removes SG+CCC.

Definition at line 99 of file DecorKeyHelpers.cxx.

{
  // Remove container name from key
  const std::string toerase = contKey.fullKey().key() + ".";
  const size_t pos = key.find(toerase);
  if (pos != std::string::npos) {
    key.erase(pos, toerase.size());
  }
 
}

reserve()

virtual void SG::reserve ( size_t sz )

overridevirtual

Change the capacity of all aux data vectors.

Parameters

sz	The new capacity.

This should be called when the capacity of the container changes (by reserve). This should change the capacity for the vectors for all aux data items.

reset()

virtual void SG::reset ( )

overridevirtual

Free all allocated elements.

All elements allocated are returned to the free state. clear should be called on them if it was provided. The elements may continue to be cached internally, without returning to the system.

resize()

virtual bool SG::resize ( size_t sz )

overridevirtual

Change the size of all aux data vectors.

Parameters

sz	The new size.

This should be called when the size of the container changes. This should resize the vectors for all aux data items.

If the size of the container grows, the new elements should be default-initialized; if it shrinks, destructors should be run as appropriate.

Should return true if it is known that none of the data pointers changed (and thus the cache does not need to be cleared), false otherwise.

safe_clid()

template<class T>

CLID SG::safe_clid ( )

constexpr

Return the class ID of T, or CLID_NULL if it doesn't have one.

Avoids compilation errors if the class ID is not defined.

set() [1/6]

void SG::set	(	const AuxVectorData &	container,
		size_t	index,
		const Link_t &	x ) const

Set the variable for one element.

Parameters

container	The container for which to set the variable.
index	The index of the desired element.
l	The ElementLink to set.

set() [2/6]

template<detail::ElementLinkRange< CONT > RANGE>

void SG::set ( const AuxVectorData & container, size_t index, const RANGE & r ) const

protected

Set the variable for one element.

Parameters

container	The container for which to set the variable.
index	The index of the desired element.
r	The variable value to set, as a range over ElementLink.

set() [3/6]

template<CxxUtils::InputRangeOverT< PAYLOAD_T > RANGE>

void SG::set	(	const AuxVectorData &	container,
		size_t	index,
		const RANGE &	x ) const

Set the variable for one element.

Parameters

container	The container from which to fetch the variable.
index	The index of the desired element.
x	The variable value to set.

set() [4/6]

template<IsConstAuxElement ELT>

void SG::set	(	const ELT &	e,
		const element_type &	x ) const

Set the variable for one element.

Parameters

e	The element for which to fetch the variable.
x	The variable value to set.
e	The element for which to set the variable.
l	The ElementLink to set.

set() [5/6]

template<IsConstAuxElement ELT, CxxUtils::InputRangeOverT< PAYLOAD_T > RANGE>

void SG::set	(	const ELT &	e,
		const RANGE &	x ) const

Set the variable for one element.

Parameters

e	The element for which to fetch the variable.
x	The variable value to set.

set() [6/6]

template<IsConstAuxElement ELT, detail::ElementLinkRange< CONT > RANGE>

void SG::set ( const ELT & e, const RANGE & x ) const

protected

Set the variable for one element.

Parameters

e	The element for which to set the variable.
r	The variable value to set, as a range over ElementLink.

setConstStore()

void SG::setConstStore

(

const SG::IConstAuxStore *

store

)

Synonym for setStore with IConstAuxStore.

Parameters

store

The new store.

setHadPrivateData()

void SG::setHadPrivateData ( )

private

Record that this element used to have private data.

setHavePrivateData()

void SG::setHavePrivateData ( )

private

Record that this element currently has private data.

setIndex() [1/2]

void SG::setIndex ( size_t index )

private

Set the index of this element within its container.

setIndex() [2/2]

void SG::setIndex ( size_t index, SG::AuxVectorData * container )

private

Set the index/container for this element.

Parameters

index	The index of this object within the container.
container	The container holding this object. May be null if this object is being removed from a container.

Usually this simply sets the index and container members of this object. However, in the case where this object has an associated private store, then we need to deal with releasing the store if the object is being added to a container, or making a new store if the object is being removed from a container.

setIndexPrivate()

bool SG::setIndexPrivate ( size_t index, SG::AuxVectorData * container )

private

Set the index/container for this element.

Parameters

index	The index of this object within the container.
container	The container holding this object. May be null if this object is being removed from a container.

This is called from setIndex when we have a private store to deal with.

setNonConstStore()

void SG::setNonConstStore

(

SG::IAuxStore *

store

)

Synonym for setStore with IAuxStore.

Parameters

store

The new store.

setNoPrivateData()

void SG::setNoPrivateData ( )

private

Record that this element does not have private data.

setOption()

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

overridevirtual

Set an option for an auxiliary data variable.

Parameters

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

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

setStore() [1/3]

void SG::setStore

(

const DataLink< SG::IConstAuxStore > &

store

)

Set the store associated with this object.

Parameters

store

The new store.

If store is nonzero, this adds a standalone store to the object. The object must not be in a container and must not have a private store. If store is zero, this removes a standalone store.

setStore() [2/3]

void SG::setStore

(

const SG::IConstAuxStore *

store

)

Set the store associated with this object.

Parameters

store

The new store.

If store is nonzero, this adds a standalone store to the object. The object must not be in a container and must not have a private store. If store is zero, this removes a standalone store.

setStore() [3/3]

void SG::setStore

(

SG::IAuxStore *

store

)

Set the store associated with this object.

Parameters

store

The new store.

If store is nonzero, this adds a standalone store to the object. The object must not be in a container and must not have a private store. If store is zero, this removes a standalone store.

setStore1()

AuxElementStandaloneData * SG::AuxElement::setStore1 ( const SG::IConstAuxStore * store )

private

Set the store associated with this object.

Parameters

store

The new store.

Helper for setStore. Creates the AuxElementStandaloneData object if needed and returns it.

Parameters

store

The new store.

Helper for setStore. Creates the @x AuxElementStandaloneData object if needed and returns it.

Definition at line 448 of file AuxElement.cxx.

{
  if (store) {
    // Want this object be standalone.
    if (!m_container) {
      // Not in a container (and no private store).  Make a new object.
      AuxElementStandaloneData* data = new AuxElementStandaloneData;
      IAuxElement::setHavePrivateData();
      m_container = data;
      return data;
    }
    if (usingStandaloneStore()) {
      // Standalone --- return existing object.
      return static_cast<AuxElementStandaloneData*> (container());
    }
    // Otherwise, it's an error.
    throw ExcBadPrivateStore ("Attempt to attach a standalone store to an "
                              "object in a container or with a private store.");
  }
 
  else {
    // Getting rid of a standalone store.
    if (usingStandaloneStore()) {
      IAuxElement::setNoPrivateData();
      delete m_container;
      m_container = 0;
    }
    else if (m_container != 0)
      throw ExcBadPrivateStore ("Attempt to remove a standalone store from an "
                                "object in a container or with a private store.");
    return 0;
  }
}

sgkeyEqual()

bool SG::sgkeyEqual ( const sgkey_t a, const sgkey_t b )

inlineconstexpr

Compare two sgkeys for equality.

Definition at line 39 of file sgkey_t.h.

{
  return a == b;
}

sgkeyLess()

bool SG::sgkeyLess ( const sgkey_t a, const sgkey_t b )

inlineconstexpr

Compare two sgkeys for ordering.

Definition at line 49 of file sgkey_t.h.

{
  return a < b;
}

sgkeyShort()

uint32_t SG::sgkeyShort ( const sgkey_t k )

inlineconstexpr

Convert a sgkey to the 32-bit form used for older data.

Definition at line 85 of file sgkey_t.h.

{
  return k;
}

shift()

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

overridevirtual

Shift the elements of the container.

Parameters

pos	The starting index for the shift.
offs	The (signed) amount of the shift.

This operation shifts the elements in the vectors for all aux data items, to implement an insertion or deletion. offs may be either positive or negative.

If offs is positive, then the container is growing. The container size should be increased by offs, the element at pos moved to pos + offs, and similarly for following elements. The elements between pos and pos + offs should be default-initialized.

If offs is negative, then the container is shrinking. The element at pos should be moved to pos + offs, and similarly for following elements. The container should then be shrunk by -offs elements (running destructors as appropriate).

simpleStringHash()

int SG::simpleStringHash ( const std::string & str, int maxInt = 0xFFFF )

inline

simple hash function derived from Sedgewick Algorithms in C++ 3rd ed

Parameters

str	the string to be hashed
maxInt	the maximum value the function returns. Hash collision probability is 1/min(maxInt, 2**127)

Definition at line 16 of file hash_functions.h.

                                                                     {
    int h(0), a(127);
    for (std::string::size_type iC=0; iC<str.size(); iC++)
      h = (a*h + str[iC]) % maxInt;    
    return h;  
  }

size()

size_t SG::size ( ) const

overridevirtual

Return the number of elements in the store.

May return 0 for a store with no aux data.

size_noLock()

size_t SG::size_noLock ( ) const

private

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

slowClear()

void SG::ArenaHeapAllocator::slowClear ( )

private

Call clear() for all allocated elements.

Definition at line 174 of file ArenaHeapAllocator.cxx.

{
  // Make a list of all free elements, in sorted order.
  std::vector<pointer> free_ptrs;
  free_ptrs.reserve (m_stats.elts.total - m_stats.elts.inuse);
  for (pointer p = m_freeptr; p; p = link(p)) {
    free_ptrs.push_back (p);
  }
  std::sort (free_ptrs.begin(), free_ptrs.end());
 
  // Make a list of all used blocks, in sorted order.
  std::vector<ArenaBlock*> blocks;
  for (ArenaBlock* p = m_blocks; p; p = p->link()) {
    blocks.push_back (p);
  }
  std::sort (blocks.begin(), blocks.end());
 
  // Walk through both of these lists.
  // For each block, walk through its elements, and call @c clear
  // for those not on the free list.
  std::vector<pointer>::iterator pi = free_ptrs.begin();
  std::vector<pointer>::iterator pi_end = free_ptrs.end();
  std::vector<ArenaBlock*>::iterator bi = blocks.begin();
  std::vector<ArenaBlock*>::iterator bi_end = blocks.end();
  func_t* clear = m_params.clear;
  for (; bi != bi_end; ++bi) {
    ArenaBlock& bl = **bi;
    size_t sz = bl.size();
    size_t elt_size = bl.eltSize();
    for (size_t i = 0; i < sz; i++) {
      pointer ptr = bl.index (i, elt_size);
      if (pi != pi_end && ptr == *pi) {
        ++pi;
      }
      else {
        //'clear' is checked for validity by the caller
        //coverity[NULL_FIELD:FALSE]
        clear (ptr);
      }
    }
  }
}

standalone()

bool SG::AuxStoreInternal::standalone

(

)

const

Return the standalone flag.

Definition at line 70 of file AuxStoreInternal.cxx.

{
  return m_standalone;
}

Storable_cast() [1/2]

template<typename T>

T * SG::Storable_cast	(	DataObject *	pDObj,
		bool	quiet = true,
		IRegisterTransient *	irt = 0,
		bool	isConst = true )

Definition at line 37 of file StorableConversions.h.

                                      {
    T* result;
    return  fromStorable(pDObj, result, quiet, irt, isConst) ? result : 0;
  }

Storable_cast() [2/2]

void * SG::Storable_cast	(	DataObject *	pDObj,
		CLID	clid,
		const std::type_info *	tinfo = nullptr,
		bool	quiet = false,
		IRegisterTransient *	irt = 0,
		bool	isConst = true )

Try to get the pointer back from a DataObject, converted to be of type clid.

Parameters

pDObj	The DataObject.
clid	The ID of the class to which to convert.
tinfo	type_info for the object being converted (optional).
quiet	If true, suppress warning messages.
irt	To be called if we make a new instance.
isConst	True if the object being converted is regarded as const.

Only works if the DataObject is a DataBucket. Returns 0 on failure,

Definition at line 88 of file StorableConversions.cxx.

{
  return fromStorable (pDObj, clid, tinfo, quiet, irt, isConst);
}

swap() [1/2]

void SG::swap

(

ArenaHeapAllocator &

other

)

Swap.

swap() [2/2]

template<class T>

void SG::swap	(	ArenaSharedHeapSTLAllocator< T > &	a,
		ArenaSharedHeapSTLAllocator< T > &	b )

Definition at line 483 of file ArenaSharedHeapSTLAllocator.h.

{
  a.swap (b);
}

throwExcAllocOwnership()

void SG::throwExcAllocOwnership

(

)

Throw a SG::ExcAllocOwnership exception.

Definition at line 636 of file Control/AthContainers/Root/exceptions.cxx.

{
  throw ExcAllocOwnership();
}

throwExcBadDataProxyCast()

void SG::throwExcBadDataProxyCast	(	const DataProxy &	proxy,
		const std::type_info &	tid )

Throw an ExcBadDataProxyCast exception.

Parameters

proxy	The proxy from which we're trying to cast.
tid	Type to which we're trying to convert the object.

Definition at line 57 of file Control/SGTools/src/exceptions.cxx.

{
  throw ExcBadDataProxyCast (proxy.clID(), tid);
}

throwExcBadDecorElement()

void SG::throwExcBadDecorElement	(	Gaudi::DataHandle::Mode	mode,
		CLID	clid,
		const std::string &	decorKey )

Throw a SG::ExcBadDecorElement exception.

Definition at line 488 of file Control/StoreGate/src/exceptions.cxx.

{
  throw SG::ExcBadDecorElement (mode, clid, decorKey);
}

throwExcBadForwardLink()

void SG::throwExcBadForwardLink	(	size_t	index,
		size_t	size,
		const std::string &	name )

Throw a SG::ExcBadForwardLink exception.

Parameters

index	Index in the link.
size	Size of the referenced container.
name	Type name of the container.

Definition at line 155 of file Control/AthLinks/src/exceptions.cxx.

{
  throw ExcBadForwardLink (index, size, name);
}

throwExcBadThinning()

void SG::throwExcBadThinning	(	CLID	clid,
		const std::string &	key,
		SG::sgkey_t	sgkey )

Throw a SG::ExcBadThinning exception.

Parameters

clid	CLID of the link.
key	String key of the link.
sgkey	Hashed key of the link.

Definition at line 344 of file Control/AthLinks/src/exceptions.cxx.

{
  throw ExcBadThinning (clid, key, sgkey);
}

throwExcBadToTransient()

void SG::throwExcBadToTransient

(

)

Throw a SG::ExcBadToTransient exception.

Definition at line 272 of file Control/AthLinks/src/exceptions.cxx.

{
  throw ExcBadToTransient();
}

throwExcElementNotFound()

void SG::throwExcElementNotFound

(

const char *

where

)

Throw a SG::ExcElementNotFound exception.

Parameters

where

The operation being attempted.

Definition at line 180 of file Control/AthLinks/src/exceptions.cxx.

{
  throw ExcElementNotFound (where);
}

throwExcIncomparableEL()

void SG::throwExcIncomparableEL

(

)

Throw a SG::IncomparableEL exception.

Throw a SG::ExcIncomparableSG exception.

Definition at line 250 of file Control/AthLinks/src/exceptions.cxx.

{
  throw ExcIncomparableEL();
}

throwExcIndexNotFound()

void SG::throwExcIndexNotFound

(

const char *

where

)

Throw a SG::ExcIndexNotFound exception.

Parameters

where

The operation being attempted.

Definition at line 228 of file Control/AthLinks/src/exceptions.cxx.

{
  throw ExcIndexNotFound (where);
}

throwExcInvalidIndex()

void SG::throwExcInvalidIndex

(

const char *

where

)

Throw a SG::ExcInvalidIndex exception.

Parameters

where

The operation being attempted.

Definition at line 204 of file Control/AthLinks/src/exceptions.cxx.

{
  throw ExcInvalidIndex (where);
}

throwExcInvalidLink()

void SG::throwExcInvalidLink	(	CLID	clid,
		const std::string &	key,
		SG::sgkey_t	sgkey )

Throw a SG::ExcInvalidLink exception.

Parameters

clid	CLID of the link.
key	String key of the link.
sgkey	Hashed key of the link.

Definition at line 111 of file Control/AthLinks/src/exceptions.cxx.

{
  throw ExcInvalidLink (clid, key, sgkey);
}

throwExcMissingBaseInfo()

void SG::throwExcMissingBaseInfo

(

const std::type_info &

ti

)

Throw a SG::ExcMissingBaseInfo exception.

Parameters

ti	type_info for the class with the missing base info.

Definition at line 447 of file Control/AthContainers/Root/exceptions.cxx.

{
  throw ExcMissingBaseInfo (ti);
}

throwExcMissingViewVectorCLID()

void SG::throwExcMissingViewVectorCLID

(

const std::type_info &

ti

)

Throw a SG::ExcMissingViewVectorCLID exception.

Throw a SG::ExcViewVectorCLID exception.

Parameters

ti	type_info for the class with the missing CLID.

Definition at line 425 of file Control/AthContainers/Root/exceptions.cxx.

{
  throw ExcMissingViewVectorCLID (ti);
}

throwExcNonConstHandleKey()

void SG::throwExcNonConstHandleKey	(	CLID	clid,
		const std::string &	sgkey,
		const std::string &	storename )

Throw a SG::ExcNonConstHandleKey exception.

Parameters

clid	CLID from the key.
sgkey	StoreGate key from the key.
storename	Store name from the key.

Definition at line 337 of file Control/StoreGate/src/exceptions.cxx.

{
  throw ExcNonConstHandleKey (clid, sgkey, storename);
}

throwExcNonowningContainer()

void SG::throwExcNonowningContainer

(

)

Throw a SG::ExcNonowningContainer exception.

Definition at line 307 of file Control/AthContainers/Root/exceptions.cxx.

{
  throw ExcNonowningContainer();
}

throwExcNullHandleKey()

void SG::throwExcNullHandleKey

(

)

Throw a SG::ExcNullHandleKey exception.

Definition at line 32 of file Control/StoreGate/src/exceptions.cxx.

{
  throw ExcNullHandleKey();
}

throwExcNullReadHandle()

void SG::throwExcNullReadHandle	(	CLID	clid,
		const std::string &	sgkey,
		const std::string &	storename )

Throw a SG::ExcNullReadHandle exception.

Parameters

clid	CLID from the key.
sgkey	StoreGate key from the key.
storename	Store name from the key.

Definition at line 247 of file Control/StoreGate/src/exceptions.cxx.

{
  throw ExcNullReadHandle (clid, sgkey, storename);
}

throwExcNullUpdateHandle()

void SG::throwExcNullUpdateHandle	(	CLID	clid,
		const std::string &	sgkey,
		const std::string &	storename )

Throw a SG::ExcNullUpdateHandle exception.

Parameters

clid	CLID from the key.
sgkey	StoreGate key from the key.
storename	Store name from the key.

Definition at line 292 of file Control/StoreGate/src/exceptions.cxx.

{
  throw ExcNullUpdateHandle (clid, sgkey, storename);
}

throwExcNullWriteHandle()

void SG::throwExcNullWriteHandle	(	CLID	clid,
		const std::string &	sgkey,
		const std::string &	storename )

Throw a SG::ExcNullWriteHandle exception.

Parameters

clid	CLID from the key.
sgkey	StoreGate key from the key.
storename	Store name from the key.

Definition at line 202 of file Control/StoreGate/src/exceptions.cxx.

{
  throw ExcNullWriteHandle (clid, sgkey, storename);
}

throwExcUnknownAuxItem()

void SG::throwExcUnknownAuxItem	(	const std::string &	name,
		const std::string &	clsname = "",
		const std::type_info *	typ = 0 )

Throw a SG::ExcUnknownAuxItem exception.

Parameters

name	Name of the aux data item.
clsname	Class name of the aux data item, or an empty string.
typ	Type of the item, if provided.

Definition at line 353 of file Control/AthContainers/Root/exceptions.cxx.

{
  throw ExcUnknownAuxItem (name, clsname, typ);
}

throwExcViewVectorNotView()

void SG::throwExcViewVectorNotView

(

)

Throw a SG::ExcViewVectorNotView exception.

Definition at line 400 of file Control/AthContainers/Root/exceptions.cxx.

{
  throw ExcViewVectorNotView();
}

throwJaggedVecOverlappingCopy()

void SG::throwJaggedVecOverlappingCopy

(

)

Throw a SG::ExcJaggedVecOverlappingCopy exception.

Definition at line 690 of file Control/AthContainers/Root/exceptions.cxx.

{
  throw ExcJaggedVecOverlappingCopy();
}

toTransient() [1/2]

virtual void SG::toTransient ( const EventContext & ctx )

overridevirtual

Perform post-read processing on this store.

Parameters

ctx	The current event context.

Some object types require some processing after being read before they are usable. This can be indicated by specializing SG::ToTransient for the vector type containing the variable. This method will call such a ToTransient method for all contained variables for which this is required.

toTransient() [2/2]

void SG::toTransient	(	const EventContext &	ctx,
		SG::auxid_t	auxid )

Perform post-read processing for a single variable.

Parameters

ctx	The current event context.
auxid	The ID of the variable to process.

Some object types require some processing after being read before they are usable. This can be indicated by specializing SG::ToTransient for the vector type containing the variable. This method will call such a ToTransient method for the single variable identified by AUXID.

trackIndices()

bool SG::trackIndices

(

)

const

Return true if index tracking is enabled for this object.

Always returns true. Included here to be consistent with AuxVectorBase when standalone objects may be used as template parameters.

usingPrivateStore()

bool SG::AuxElement::usingPrivateStore

(

)

const

Test to see if this object is currently using a private store.

Definition at line 280 of file AuxElement.cxx.

{
  return havePrivateData() && 
    typeid(*m_container) == typeid(AuxElementPrivateData);
}

usingStandaloneStore()

bool SG::AuxElement::usingStandaloneStore

(

)

const

Test to see if this object is currently using a standalone store.

Test to see if this object is currently using a private store.

Definition at line 290 of file AuxElement.cxx.

{
  return havePrivateData() &&
    typeid(*m_container) == typeid(AuxElementStandaloneData);
}

ViewVectorBaseStreamerFunc()

void SG::ViewVectorBaseStreamerFunc	(	TBuffer &	b,
		void *	p )

Definition at line 27 of file ViewVectorBaseStreamer.cxx.

{
  static TClass* const cl = TClass::GetClass ("SG::ViewVectorBase");
  if (b.IsReading()) {
    cl->ReadBuffer (b, p);
  } else {
    SG::ViewVectorBase* vvb = reinterpret_cast<SG::ViewVectorBase*>(p);
    vvb->toPersistent();
    cl->WriteBuffer(b, p);
  }
}

writePackedParameters()

void SG::writePackedParameters ( TBuffer & b, const SG::PackedParameters & parms )

inline

Write a set of packed parameters to a buffer.

Parameters

b	Buffer to which to write.
param	Parameters to write.

Definition at line 31 of file PackedContainerStreamer.cxx.

                                                                          {
   b << parms.nbits();
   b << parms.flags();
   if (parms.isFloat()) {
      b << parms.nmantissa();
      if (parms.hasScale())
         b << parms.scale();
   }
}

xAODInterfaceSupportingThinning()

template<class T>

bool constexpr SG::xAODInterfaceSupportingThinning ( )

constexpr

Test for an xAOD interface class supporting thinning.

Returns true if T derives from either AuxVectorBase or AuxElement and T::supportsThinning is true.

Definition at line 42 of file supportsThinning.h.

                                                  {
 
  constexpr bool isxAODInterfaceObject =
    std::derived_from<T, SG::AuxVectorBase> ||
    std::derived_from<T, SG::AuxElement>;
 
  if constexpr (isxAODInterfaceObject)
    return T::supportsThinning;
  else
    return false;
}

xAODStoreSupportingThinning()

template<class T, typename std::enable_if_t< is_xAODStoreObject_v< T > > * = nullptr>

bool constexpr SG::xAODStoreSupportingThinning ( )

constexpr

Definition at line 68 of file supportsThinning.h.

{ return T::supportsThinning; }

~ArenaHeapAllocator()

SG::ArenaHeapAllocator::~ArenaHeapAllocator ( )

virtual

Destructor.

This will free all the Allocator's storage.

Definition at line 40 of file ArenaHeapAllocator.cxx.

{
  if (m_protected) {
    try {
      unprotect();
    }
    catch (const SG::ExcProtection&) {
      // Got an error from mprotect...
      std::abort();
    }
  }
  ArenaBlockAllocatorBase::eraseUnprotected();
}

~AuxElement()

SG::~AuxElement

(

)

Destructor.

Any private store is deleted.

~AuxStoreInternal()

SG::AuxStoreInternal::~AuxStoreInternal ( )

virtual

Destructor.

All contained data will be deleted.

Definition at line 43 of file AuxStoreInternal.cxx.

{
}

Variable Documentation

ArenaBlockBodyOffset

const int SG::ArenaBlockBodyOffset

static

Initial value:

                                    =
sizeof (ArenaBlock) - sizeof (ArenaBlockAlignDetail::padForAlign)

The offset from the start of the block to the first element.

Definition at line 254 of file ArenaBlock.h.

auxAllocatorNamePrefix

const char* SG::auxAllocatorNamePrefix = "std::allocator<"

constexpr

Definition at line 29 of file AuxDataTraits.h.

auxid_set_size_hint

const auxid_t SG::auxid_set_size_hint = 2048

static

A hint for how large we should make the auxid bitsets.

It's best if we don't need to reallocate them later; but on the other hand, we don't want this to be larger than it really needs to be. The largest auxid i saw in a reco job was about 1800, so this is probably good for now.

Definition at line 40 of file AuxTypes.h.

DEFAULTKEY

const std::string SG::DEFAULTKEY = ""

Definition at line 12 of file DefaultKey.h.

defaultQuiet

bool SG::defaultQuiet = false

staticconstexpr

Definition at line 45 of file StoreGate/StoreGate/VarHandleBase.h.

getDataSourcePointerFunc

getDataSourcePointerFunc_t* SG::getDataSourcePointerFunc

extern

is_xAODStoreObject_v

template<class T>

bool SG::is_xAODStoreObject_v

inlineconstexpr

Initial value:

                                         =
std::is_base_of_v<SG::IAuxStore, T>

Test for an xAOD auxiliary store class supporting thinning.

Returns true if T derives from IAuxStore and T::supportsThinning is true. (The enable_if's are to avoid getting undefined symbol errors when T is not an xAOD object.)

Definition at line 64 of file supportsThinning.h.

m_auxid

SG::auxid_t SG::m_auxid

private

The cached auxid.

Definition at line 253 of file Decorator.h.

m_auxids

SG::auxid_set_t SG::m_auxids

private

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

Definition at line 491 of file AuxStoreInternal.h.

m_curStore

IProxyDict * SG::CurrentEventStore::m_curStore = nullptr

thread_localstaticprivate

The current event store.

Definition at line 70 of file SGTools/SGTools/CurrentEventStore.h.

m_decorations

SG::auxid_set_t SG::m_decorations

private

Record which variables are decorations.

Definition at line 488 of file AuxStoreInternal.h.

m_freeptr

pointer SG::m_freeptr

private

Pointer to the next free element.

Definition at line 213 of file ArenaHeapAllocator.h.

m_index

size_t SG::m_index

private

The index of this element within its container. Should be 0 if this object is not within a container.

Definition at line 128 of file IAuxElement.h.

m_locked

bool SG::m_locked

private

Has this container been locked?

Definition at line 494 of file AuxStoreInternal.h.

m_mutex

mutex_t SG::m_mutex

mutableprivate

Definition at line 499 of file AuxStoreInternal.h.

m_privateStoreState

PrivateStoreState SG::m_privateStoreState

private

Definition at line 137 of file IAuxElement.h.

m_standalone

bool SG::m_standalone

private

Are we being written in standalone mode?

Definition at line 481 of file AuxStoreInternal.h.

m_vecs

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

private

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

Definition at line 485 of file AuxStoreInternal.h.

null_auxid

const auxid_t SG::null_auxid = static_cast<auxid_t> (-1)

static

To signal no aux data item.

Definition at line 30 of file AuxTypes.h.

s_sgkey_nullval

auto SG::s_sgkey_nullval

staticconstexpr

Initial value:

                                    =
static_cast<CxxUtils::detail::ConcurrentHashmapVal_t> (-1)

Definition at line 24 of file sgkey_utilities.h.

supportsThinning

bool SG::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 960 of file AuxElement.h.

viewVectorBaseStreamerInstance

InstallViewVectorBaseStreamer SG::viewVectorBaseStreamerInstance

Definition at line 53 of file ViewVectorBaseStreamer.cxx.