SG Namespace Reference

Forward declaration. More...

Namespaces
namespace	ArenaBlockAlignDetail
namespace	CondHandleDefault
namespace	detail

Classes
class	Accessor
	Helper class to provide type-safe access to aux data. More...
class	Accessor< JaggedVecElt< PAYLOAD_T >, ALLOC >
	Helper class to provide type-safe access to aux data, specialized for JaggedVecElt. 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	Arena
	Collection of memory allocators with a common lifetime,. More...
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	ArenaAllocatorRegistryImpl
	ArenaAllocatorRegistry implementation class. 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...
class	ArenaHeapAllocator
	Heap-based allocator. More...
class	ArenaHeapSTLAllocator
	STL-style allocator wrapper for ArenaHeapAllocator. More...
class	ArenaHeapSTLAllocator< T, T >
	STL-style allocator wrapper for ArenaHeapAllocator. More...
class	ArenaHeapSTLAllocator_initParams
	Initializer for pool allocator parameters. More...
class	ArenaNonConstHeapSTLAllocator
	Forward declaration. More...
class	ArenaNonConstPoolSTLAllocator
	Forward declaration. More...
class	ArenaPoolAllocator
	Pool-based allocator. More...
class	ArenaPoolSTLAllocator
	STL-style allocator wrapper for ArenaPoolAllocator. More...
class	ArenaPoolSTLAllocator< T *, VETO >
	STL-style allocator wrapper for ArenaPoolAllocator. More...
class	ArenaPoolSTLAllocator< T, typename std::enable_if<!std::is_pointer_v< T >, T >::type >
	STL-style allocator wrapper for ArenaPoolAllocator. More...
class	ArenaPoolSTLAllocator_initParams
	Initializer for pool allocator parameters. More...
class	ArenaSharedHeapSTLAllocator
	Forward declaration. More...
class	ArenaSharedHeapSTLHeader
	Common header class for ArenaSharedHeapSTLAllocator. More...
class	AtomicConstAccessor
	Access an auxiliary variable atomically. More...
class	AtomicDecorator
	Access an auxiliary variable atomically. More...
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	AuxDataTraits
	Allow customizing how aux data types are treated. More...
class	AuxDataTraits< bool, ALLOC >
	Allow customizing how aux data types are treated. More...
class	AuxElement
	Base class for elements of a container that can have aux data. More...
class	AuxElementComplete
	Wrapper to automatically create a private store for an element. More...
class	AuxElementData
	Internal data container. More...
class	AuxElementPrivateData
	Internal data container for private store. More...
class	AuxElementStandaloneData
	Internal data container for standalone store. More...
class	auxid_set_t
	A set of aux data identifiers. More...
struct	AuxStore_traits
	Associate AuxStore classes with EDM container classes (default implementation). 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< DOBJ * >
	Associate AuxStore classes with EDM container classes. 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...
class	AuxStoreConstMem
	IConstAuxStore implementation referencing external buffers. More...
class	AuxStoreInternal
	An auxiliary data store that holds data internally. More...
class	AuxStoreStandalone
	Auxiliary data store for standalone objects. More...
class	AuxTypePlaceholder
	Used as type_info when we read an aux data item but it doesn't exist in the registry. More...
class	AuxTypeRegistry
	Handle mappings between names and auxid_t. More...
class	AuxTypeRegistryImpl
	@Brief Implementation class for AuxTypeRegistry. More...
class	AuxTypeVectorFactory
	Factory object that creates vectors using AuxTypeVector. More...
class	AuxTypeVectorFactory< JaggedVecElt< T >, ALLOC >
	Factory object that creates vectors using AuxTypeVector. More...
class	AuxTypeVectorFactory< PackedLink< CONT >, ALLOC >
	Factory object that creates vectors for packed links. More...
class	AuxTypeVectorFactory< std::vector< PackedLink< CONT >, VALLOC >, ALLOC >
	Factory object that creates vectors of vectors of packed links. More...
class	AuxTypeVectorFactoryImpl
	Factory object that creates vectors using AuxTypeVector. More...
class	AuxTypeVectorHolder
	Implementation of IAuxTypeVector for specific types. More...
class	AuxTypeVectorT
	Implementation of IAuxTypeVector holding a vector instance. More...
class	AuxVectorBase
	Manage index tracking and synchronization of auxiliary data. More...
class	AuxVectorData
	Manage lookup of vectors of auxiliary data. More...
class	AuxVectorInterface
	Make an AuxVectorData object from either a raw array or an aux store. More...
class	BaseInfo
	Provide an interface for finding inheritance information at run time. More...
class	BaseInfo< CaloConstCellContainer >
class	BaseInfo< ConstDataVector< DV > >
	Let the BaseInfo for ConstDataVector forward to that of the base DataVector. More...
class	BaseInfo< DataVectorWithAlloc< DV, ALLOC > >
	Let the BaseInfo for DataVectorWithAlloc forward to that of the base DataVector. More...
class	BaseInfoBase
	The non-template portion of the BaseInfo implementation. More...
struct	BaseInfoBaseImpl
class	BaseInfoImpl
struct	BaseList
	Represent a list of base classes. More...
struct	BaseList< BASE, REST... >
	Represent a non-empty list of base classes. More...
struct	Bases
	Traits class to hold derivation information. More...
struct	Bases< CondCont< T > >
struct	Bases< CondContMixed< T > >
struct	Bases< DataVector< T, DataModel_detail::NoBase > >
	Declare DataVector base class. More...
struct	Bases< TileContainer< T > >
struct	Bases< ViewVector< DV > >
	Specialize to declare that ViewVector<DV> derives from DV. More...
struct	BaseType
	Helper metafunction to get base class types. More...
struct	BaseType< Virtual< T > >
class	CondHandleKey
class	ConstAccessor
	Helper class to provide constant type-safe access to aux data. More...
class	ConstAccessor< SG::JaggedVecElt< PAYLOAD_T >, ALLOC >
	Helper class to provide constant type-safe access to aux data, specialized for JaggedVecElt. 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...
class	ConstAuxElement
	Const part of AuxElement. More...
class	ConstIterator
	a const_iterator facade to DataHandle. More...
class	CopyConversion
	Base class for copy conversions, templated on source and destination classes. More...
class	CopyConversionBase
	Base class for copy conversions. More...
class	CurrentEventStore
	Hold a pointer to the current event store. More...
class	DataBucket
struct	DataBucketTrait
	Metafunction to find the proper DataBucket class for T. More...
struct	DataBucketTrait< CaloConstCellContainer, U >
struct	DataBucketTrait< ConstDataVector< DV >, U >
	Metafunction to find the proper DataBucket class for the first template argument. More...
struct	DataBucketTrait< DataVector< T >, U >
	Metafunction to find the proper DataBucket class for T. More...
struct	DataBucketTrait< DataVectorWithAlloc< DV, ALLOC >, U >
	Metafunction to find the proper DataBucket class for the first template argument. More...
struct	DataBucketTrait< MetaCont< T >, U >
	Metafunction to find the proper DataBucket class for T. More...
class	DataPoolNullClear
	Null cleanup functional — does no actual cleanup. More...
class	DataProxy
class	DataProxyHolder
	Manage DataProxy reference in ElementLink/DataLink. More...
class	DataStore
	Hold DataProxy instances associated with a store. More...
class	Decorator
	Helper class to provide type-safe access to aux data. More...
class	Decorator< JaggedVecElt< PAYLOAD_T >, ALLOC >
	Helper class to provide type-safe access to aux data, specialized for JaggedVecElt. More...
class	Decorator< PackedLink< CONT >, ALLOC >
	Helper class to provide type-safe access to aux data, specialized for PackedLink. More...
class	Decorator< 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	DVLConstDataVectorBucket
	DataBucket class for ConstDataVector. More...
class	DVLDataBucket
	A DataBucket specialized for DataVector/DataList. More...
class	DVLDataVectorWithAllocBucket
	DataBucket class for DataVectorWithAlloc. More...
class	ElementLinkTraits
	ElementLinkTraits class to specialize. 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	ELVRef
	a short ref to an ElementLink into an ElementLinkVector. More...
class	ExcAllocOwnership
	Exception — Bad allocation ownership. More...
class	ExcAuxTypeMismatch
	Exception — Type mismatch for aux variable. More...
class	ExcBadAuxVar
	Exception — Attempt to retrieve nonexistent aux data item. More...
class	ExcBadContext
	Exception — Bad EventContext extension while building ReadCondHandle. More...
class	ExcBadDataProxyCast
	Exception — Bad cast of DataProxy with CLID. More...
class	ExcBadDecorElement
	Exception — DecorHandle given an element not in the requested container. More...
class	ExcBadForwardLink
	Exception — ForwardIndexingPolicy: internal link state is invalid. More...
class	ExcBadHandleKey
	Exception — Bad key format for VarHandleKey. More...
class	ExcBadInitializedReadHandleKey
	Exception — Initialization of InitializedReadHandleKey failed. More...
class	ExcBadIterSwap
	Exception — Bad iter_swap. More...
class	ExcBadPrivateStore
	Exception — Bad use of private store. More...
class	ExcBadReadCondHandleInit
	Exception — ReadCondHandle didn't initialize in getRange(). More...
class	ExcBadThinning
	Exception – Bad thinning request. More...
class	ExcBadToTransient
	Exception — bad toTransient. More...
class	ExcBadVarName
	Exception — Bad name for auxiliary variable. More...
class	ExcCLIDMismatch
	Exception — Attempt to set DataLink / ElementLink with CLID <clid> to object with CLID <clid>. More...
class	ExcConstAuxData
	Exception — Non-const operation performed on const aux data. More...
class	ExcConstObject
	Exception — Tried to retrieve non-const pointer to const object. More...
class	ExcConstStorable
	Exception – Tried to retrieve const storable as a non-const pointer. More...
class	ExcDifferentArenas
	Exception — Attempt to assign between ArenaSharedHeapSTLAllocators for different arenas. More...
class	ExcDVToELV
	Exception — Can't convert DataVector to vector of ElementLinks. More...
class	ExcElementNotFound
	Exception — element not found. More...
class	ExcFlagMismatch
	Exception — Flag mismatch for aux variable. More...
class	ExcForbiddenMethod
	Exception — Forbidden method called. More...
class	ExcHandleInitError
	Exception — Error initializing VarHandle from VarHandleKey. More...
class	ExcIncomparableEL
	Exception — incomparable ElementLink. More...
class	ExcIndexNotFound
	Exception — index not found. 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	ExcInsertMoveOwnershipMismatch
	Exception — Ownership mismatch for insertMove. More...
class	ExcInvalidIndex
	Exception — invalid index. More...
class	ExcInvalidIterator
	Exception — Deference invalid SG::Iterator. More...
class	ExcInvalidLink
	Exception — Attempt to dereference invalid DataLink / ElementLink ". More...
class	ExcInvalidThinningTarget
	Exception — ThinningHandle target does not exist. More...
class	ExcJaggedVecOverlappingCopy
	Exception — Overlapping copies not implemented for jagged vectors. More...
class	ExcLinkMismatch
	Exception — Linked variable mismatch. More...
class	ExcMissingBaseInfo
	Exception — Missing BaseInfo. More...
class	ExcMissingViewVectorCLID
	Exception — Missing CLID for ViewVector. More...
class	ExcNoAuxStore
	Exception — Aux data requested from object with no store. More...
class	ExcNoCondCont
	Exception — Can't retrieve CondCont from ReadCondHandle. More...
class	ExcNoLinkedVar
	Exception — Linked variable not found. More...
class	ExcNonConstHandleKey
	Exception — Attempt to get non-const VarHandleKey from non-owning VarHandle. More...
class	ExcNonowningContainer
	Exception — Attempted to insert a unique_ptr to a non-owning container. More...
class	ExcNoRange
	Exception — Range not set in ReadCondHandle::getRange(). More...
class	ExcNullHandleKey
	Exception — Attempt to dereference a Read/Write/UpdateHandle with a null key. More...
class	ExcNullReadHandle
	Exception — Deference of read handle failed. More...
class	ExcNullUpdateHandle
	Exception — Deference of update handle failed. More...
class	ExcNullWriteHandle
	Exception — Attempt to dereference write handle before record. More...
class	ExcPointerNotInSG
	Exception — The object referenced by a DataLink / ElementLink is not registered in SG. More...
class	ExcProtected
	Exception — Attempt to change protected arena. More...
class	ExcProtection
	Exception — Attempt to change memory protection failed. More...
class	ExcProxyCollision
	Exception — Proxy collision for clid/key. More...
class	ExcSgkeyCollision
	Exception — sgkey hash collision. More...
class	ExcStoreLocked
	Exception — Attempted to modify auxiliary data in a locked store. More...
class	ExcUninitKey
	Exception — Tried to create a handle from an uninitialized key. More...
class	ExcUnknownAuxItem
	Exception — Unknown aux data item. 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	ExcViewVectorNotView
	Exception — ViewVector not in view mode. More...
class	Folder
	a run-time configurable list of data objects More...
class	FolderItem
	a Folder item (data object) is identified by the clid/key pair More...
class	ForwardIndexingPolicy
	Indexing policy for a vector-like container. More...
struct	GenerateIndexingPolicy
class	GenericElementLinkBase
	Generic base class for ElementLinks. More...
struct	HandleClassifier
	Helper to classify the type of a handle property. More...
class	HandleKeyArray
struct	HiveEventSlot
class	HiveMgrSvc
class	IAuxElement
	Flag that a class may have auxiliary data associated with it. 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	IConstAuxStore
	Interface for const operations on an auxiliary store. More...
class	IdentContIndexingPolicy
	Indexing policy for an IdentifiableContainer. More...
class	IFolder
	a run-time configurable list of data objects More...
class	IndexHolder
	Store an ElementLink index for non-vector containers. More...
class	InitializedReadHandleKey
	ReadHandleKey that initializes during construction. More...
struct	InstallPackedContainerStreamer
struct	InstallViewVectorBaseStreamer
class	IRegisterTransient
	Interface for registering a transient object in t2p map. More...
class	IsMostDerivedFlag
	Holder for the is-most-derived flag. More...
struct	IsSTLSequence
struct	IsThreadSafeForUH
struct	IsThreadSafeForUH< int, std::true_type >
struct	IsThreadSafeForUH< T, typename T::thread_safe >
class	Iterator
	an iterator facade to DataHandle. More...
class	JaggedVecElt
	Describe one element of a jagged vector. More...
class	JaggedVecEltBase
	Describe one element of a jagged vector (base class). More...
class	JaggedVecVectorFactory
	Factory objects that creates vectors for packed links. More...
class	JaggedVecVectorHolder
	Implementation of IAuxTypeVector for JaggedVec types. More...
class	JaggedVecVectorT
	Implementation of IAuxTypeVector holding a vector of JaggedVec. More...
class	LockedAllocator
	A pointer type that holds a lock on an allocator object. More...
class	MapIndexingPolicy
	Indexing policy for a map-like container. More...
class	MetaContDataBucket
	Allow converting MetaCont<T> to T. More...
class	MetaHandleKey
class	NoAuxStore
	Mark that there's no associated AuxStore class. More...
struct	NoBase
	Marker to indicate a nonexistent base class. More...
class	NotHandleType
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	PackedContainer
	Container to hold aux data to be stored in a packed form. More...
class	PackedContainerStreamer
	Streamer for reading/writing SG::PackedContainer instances. More...
class	PackedConverter
	Helper for packing/unpacking a PackedContainer to/from a stream. More...
struct	PackedLink
	A packed version of ElementLink. More...
struct	PackedLinkBase
	A packed version of ElementLink. More...
class	PackedLinkVectorFactory
	Factory object that creates vectors for packed links. More...
class	PackedLinkVectorHolder
	Implementation of IAuxTypeVector for PackedLink types. More...
class	PackedLinkVectorT
	Implementation of IAuxTypeVector holding a vector of PackedLink. More...
class	PackedLinkVVectorFactory
	Factory object that creates vectors of vectors of packed links. More...
class	PackedLinkVVectorHolder
	Implementation of IAuxTypeVector for a vector of PackedLink. More...
class	PackedParameters
	Describe how the contents of a PackedContainer are to be saved. More...
struct	ptrhash
	Improved hash function for pointers. More...
class	PyDataBucket
	Concrete DataBucket that holds the object via a void* and uses the Root dictionary to do conversions. 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...
struct	PyProxyMgr
	A helper class to manage accesses to PyProxies. More...
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	ReadMetaHandle
class	ReadMetaHandleKey
struct	RegisterAddBaseInit
struct	RegisterAddCopyConversionInit
struct	RemapImpl
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	SetIndexingPolicy
	Indexing policy for a set-like container. More...
struct	SGKeyEqual
	Comparison functional for sgkey_t. More...
struct	SGKeyHash
	Hash functional for sgkey_t. More...
class	ShallowCopyDecorDeps
	Helper to propagate decoration dependencies to a shallow copy. More...
class	SlotSpecificObj
	Maintain a set of objects, one per slot. More...
class	StringPool
class	StringPoolImpl
class	SymlinkDataObject
	Helper for symLink_impl. More...
class	T2pMap
struct	TestSequenceTag
struct	TestSequenceTag< CONTAINER, typename CONTAINER::isSequence >
class	ThinningCache
	Cache thinning decisions for converters. More...
class	ThinningDecision
	Hold thinning decisions for one container. More...
class	ThinningDecisionBase
	Hold thinning decisions for one container. 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	ThinningInfo
	Hold thinning/slimming information for a given object. More...
struct	TopBase
	Calculate topmost base accessible via SG_BASES. More...
struct	TopBase< DataVector< T, DataModel_detail::NoBase > >
struct	TopBase< SG::NoBase >
class	TransientAddress
class	TypelessConstAccessor
	Helper class to provide const generic access to aux data. 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...
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	VarHandleKeyArrayType
class	VarHandleKeyProperty
	VarHandleKeyProperty is the class which wraps a SG::VarHandleKey. More...
class	VarHandleKeyType
class	VarHandleType
class	VersionedKey
	a StoreGateSvc key with a version number. More...
class	View
	A "view" of the event store (IProxyDict). More...
class	ViewVectorBase
	Hold the persistent representation for a ViewVector. More...
struct	Virtual
	Wrapper to indicate virtual derivation. 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...
struct	Zero
	Helper to specialize how to make an initialized instance of T. More...
struct	Zero< Eigen::Matrix< SCALAR, ROWS, COLS, OPTIONS, MAXROWS, MAXCOLS > >

Concepts
concept	IsConstAuxElement
	Test if T is compatible with ConstAuxElement.
concept	IsAuxElement
	Test if T is compatible with AuxElement.

Typedefs
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<class T>
using	BaseType_t = typename SG::BaseType<T>::type
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.
using	SelectionVetoes = std::unordered_map<std::string, SG::auxid_set_t>
	Map of vetoed variables.
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 , Linked = 0x02 , SkipNameCheck = 0x80 ,   ATH_BITMASK }
	Additional flags to qualify an auxiliary variable. 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.
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)
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.
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.
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).
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, typename std::enable_if_t< is_xAODInterfaceObject_v< T > > * = nullptr>
bool constexpr	xAODInterfaceSupportingThinning ()
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.
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.
bool	isTransientKey (const std::string &key)
	Test to see if a key is transoent.
std::string	transientKey (const std::string &key)
	Make a key transient.
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.
constexpr const char *	auxAllocatorNamePrefix = "std::allocator<"
template<class T>
constexpr bool	is_xAODInterfaceObject_v
	Test for an xAOD interface class supporting thinning.
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.
const std::string	DEFAULTKEY = ""
static constexpr auto	s_sgkey_nullval
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

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 381 of file AuxTypeVector.h.

BaseType_t

template<class T>

using SG::BaseType_t = typename SG::BaseType<T>::type

Definition at line 62 of file Bases.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.

ConstProxyIterator

typedef ProxyMap::const_iterator SG::ConstProxyIterator

Definition at line 24 of file ProxyMap.h.

DataObjectSharedPtr

template<CxxUtils::detail::RefCounted T>

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

Definition at line 27 of file DataObjectSharedPtr.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.

getDataSourcePointerFunc_t

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

Definition at line 34 of file DataProxy.cxx.

JaggedVecVector

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

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

Definition at line 224 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.

PackedLinkVector

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

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

Definition at line 271 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 277 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.

SelectionVetoes

using SG::SelectionVetoes = std::unordered_map<std::string, SG::auxid_set_t>

Map of vetoed variables.

Map from object SG names to a mask of vetoed variables for that object.

Definition at line 50 of file SelectionVetoes.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.

ThinningHandleKeyArray

template<class T>

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

Definition at line 28 of file ThinningHandleKeyArray.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.
Linked	Mark that this variable is linked to another one. Examples are the payload for a jagged vector and the array of DataLinks for packed ElementLinks. Linked variables are ‘global’ in that their entries do not correspond directly with entries of the container (and hence their size may be different).
SkipNameCheck
ATH_BITMASK	Enable bitwise functions on this enum; see bitmask.h.

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

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

Function Documentation

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

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

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

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

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 616 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);
  }
}

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

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

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 283 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 306 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.

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

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

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

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

isTransientKey()

bool SG::isTransientKey ( const std::string & key )

inline

Test to see if a key is transoent.

Parameters

key	The key to test.

Definition at line 41 of file transientKey.h.

{
  return !key.empty() && key[0] == '_';
}

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
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 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() [2/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() [3/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() [4/18]

template<class T>

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

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 270 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 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() [14/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() [15/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() [16/18]

template<class T>

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

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.

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

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

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]

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

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

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

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.

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

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

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

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

transientKey()

std::string SG::transientKey ( const std::string & key )

inline

Make a key transient.

Parameters

key	The key to transform;

Definition at line 51 of file transientKey.h.

{
  if (isTransientKey (key)) {
    return key;
  }
  return "_" + key;
}

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, typename std::enable_if_t< is_xAODInterfaceObject_v< T > > * = nullptr>

bool constexpr SG::xAODInterfaceSupportingThinning ( )

constexpr

Definition at line 48 of file supportsThinning.h.

{ return T::supportsThinning; }

xAODStoreSupportingThinning()

template<class T, typename std::enable_if_t< is_xAODStoreObject_v< T > > * = nullptr>

bool constexpr SG::xAODStoreSupportingThinning ( )

constexpr

Definition at line 67 of file supportsThinning.h.

{ return T::supportsThinning; }

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_xAODInterfaceObject_v

template<class T>

bool SG::is_xAODInterfaceObject_v

inlineconstexpr

Initial value:

=
  std::is_base_of_v<SG::AuxVectorBase, T> || std::is_base_of_v<SG::AuxElement, T>

Test for an xAOD interface class supporting thinning.

Returns true if T derives from either AuxVectorBase or AuxElement 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 44 of file supportsThinning.h.

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 63 of file supportsThinning.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.

viewVectorBaseStreamerInstance

InstallViewVectorBaseStreamer SG::viewVectorBaseStreamerInstance

Definition at line 53 of file ViewVectorBaseStreamer.cxx.