Handle mappings between names and auxid_t. More...

#include <AuxTypeRegistry.h>

Inheritance diagram for SG::AuxTypeRegistry:

Collaboration diagram for SG::AuxTypeRegistry:

Public Types
using	Flags = SG::AuxVarFlags
	Additional flags to qualify an auxiliary variable. More...

Public Member Functions
size_t	numVariables () const
	Return the total number of registered auxiliary variable. More...

template<class T , class ALLOC = AuxAllocator_t<T>>
SG::auxid_t	getAuxID (const std::string &name, const std::string &clsname="", const Flags flags=Flags::None, const SG::auxid_t linkedVariable=SG::null_auxid)
	Look up a name -> `auxid_t` mapping. More...

SG::auxid_t	getAuxID (const std::type_info &ti, const std::string &name, const std::string &clsname="", const Flags flags=Flags::None, const SG::auxid_t linkedVariable=SG::null_auxid)
	Look up a name -> `auxid_t` mapping. More...

SG::auxid_t	getAuxID (const std::type_info &ti_alloc, const std::type_info &ti, const std::string &name, const std::string &clsname="", const Flags flags=Flags::None, const SG::auxid_t linkedVariable=SG::null_auxid, std::unique_ptr< IAuxTypeVectorFactory >(AuxTypeRegistry::*makeFactory)() const =&AuxTypeRegistry::makeFactoryNull)
	Look up a name -> `auxid_t` mapping, specifying allocator. More...

SG::auxid_t	getAuxID (const std::string &alloc_type, const std::type_info &ti, const std::string &name, const std::string &clsname="", const Flags flags=Flags::None, const SG::auxid_t linkedVariable=SG::null_auxid)
	Look up a name -> `auxid_t` mapping, specifying allocator. More...

SG::auxid_t	findAuxID (const std::string &name, const std::string &clsname="") const
	Look up a name -> `auxid_t` mapping. More...

template<class T , class ALLOC = AuxAllocator_t<T>>
void	checkAuxID (const SG::auxid_t auxid, const Flags flags=Flags::None)
	Verify type for an aux variable. More...

void	checkAuxID (const SG::auxid_t auxid, const std::type_info &ti, const std::type_info &ti_alloc, const Flags flags)
	Verify type for an aux variable. More...

std::unique_ptr< IAuxTypeVector >	makeVector (SG::auxid_t auxid, size_t size, size_t capacity) const
	Construct a new vector to hold an aux item. More...

std::unique_ptr< IAuxTypeVector >	makeVectorFromData (SG::auxid_t auxid, void data, IAuxTypeVector linkedVector, bool isPacked, bool ownFlag) const
	Construct an `IAuxTypeVector` object from a vector. More...

std::string	getName (SG::auxid_t auxid) const
	Return the name of an aux data item. More...

std::string	getClassName (SG::auxid_t auxid) const
	Return the class name associated with an aux data item (may be blank). More...

const std::type_info *	getType (SG::auxid_t auxid) const
	Return the type of an aux data item. More...

std::string	getTypeName (SG::auxid_t auxid) const
	Return the type name of an aux data item. More...

const std::type_info *	getVecType (SG::auxid_t auxid) const
	Return the type of the STL vector used to hold an aux data item. More...

std::string	getVecTypeName (SG::auxid_t auxid) const
	Return the type of the STL vector used to hold an aux data item. More...

const std::type_info *	getAllocType (SG::auxid_t auxid) const
	Return the type of the vector allocator. More...

size_t	getEltSize (SG::auxid_t auxid) const
	Return size of an element in the STL vector. More...

Flags	getFlags (SG::auxid_t auxid) const
	Return flags associated with an auxiliary variable. More...

bool	isLinked (SG::auxid_t auxid) const
	Test whether this is a linked variable. More...

SG::auxid_t	linkedVariable (SG::auxid_t auxid) const
	Return the auxid if the linked variable, if there is one. More...

void	copy (SG::auxid_t auxid, AuxVectorData &dst, size_t dst_index, const AuxVectorData &src, size_t src_index, size_t n) const
	Copy elements between vectors. More...

void	copy (SG::auxid_t auxid, AuxVectorData &&dst, size_t dst_index, const AuxVectorData &src, size_t src_index, size_t n) const
	Copy elements between vectors. More...

void	copyForOutput (SG::auxid_t auxid, AuxVectorData &dst, size_t dst_index, const AuxVectorData &src, size_t src_index, size_t n) const
	Copy elements between vectors. More...

void	swap (SG::auxid_t auxid, AuxVectorData &a, size_t aindex, AuxVectorData &b, size_t bindex, size_t n) const
	Swap elements between vectors. More...

void	clear (SG::auxid_t auxid, AuxVectorData &dst, size_t dst_index, size_t n) const
	Clear a range of elements within a vector. More...

const IAuxTypeVectorFactory *	getFactory (const std::type_info &ti, const std::type_info &ti_alloc)
	Return the vector factory for a given vector element type. More...

const IAuxTypeVectorFactory *	getFactory (const std::type_info &ti, const std::string &alloc_name)
	Return the vector factory for a given vector element type. More...

const IAuxTypeVectorFactory *	getFactory (SG::auxid_t auxid) const
	Return the vector factory for a given auxid. More...

const IAuxTypeVectorFactory *	addFactory (const std::type_info &ti, const std::type_info &ti_alloc, std::unique_ptr< const IAuxTypeVectorFactory > factory)
	Add a new type -> factory mapping. More...

const IAuxTypeVectorFactory *	addFactory (const std::type_info &ti, const std::string &ti_alloc_name, std::unique_ptr< const IAuxTypeVectorFactory > factory)
	Add a new type -> factory mapping. More...

void	setInputRenameMap (const Athena::InputRenameMap_t *map, const IStringPool &pool)
	Declare input renaming requests. More...

const std::string &	inputRename (const std::string &key, const std::string &name) const
	Check for an input renaming of an auxiliary variable. More...

Static Public Member Functions
static AuxTypeRegistry &	instance ()
	Return the singleton registry instance. More...

static bool	isLinkedName (const std::string &name)
	Test if a variable name corresponds to a linked variable. More...

static std::string	linkedName (const std::string &name)
	Given a variable name, return the name of the corresponding linked variable. More...

static bool	classNameHasLink (const std::string &className)
	Test to see if a class name corresponds to a class with a linked variable. More...

Private Types
typedef AthContainers_detail::mutex	mutex_t

typedef AthContainers_detail::lock_guard< mutex_t >	lock_t

Private Member Functions
	AuxTypeRegistry ()
	Constructor. More...

	~AuxTypeRegistry ()
	Destructor. More...

	AuxTypeRegistry (const AuxTypeRegistry &)
	Disallow copy construction and assignment. More...

AuxTypeRegistry &	operator= (const AuxTypeRegistry &)

template<class T , class ALLOC = AuxAllocator_t<T>>
std::unique_ptr< IAuxTypeVectorFactory >	makeFactory () const
	Create an `AuxTypeVectorFactory` instance. More...

std::unique_ptr< IAuxTypeVectorFactory >	makeFactoryNull () const
	`makeFactory` implementation that always returns nullptr. More...

Static Private Member Functions
static std::string	makeKey (const std::string &name, const std::string &clsname)
	Return the key used to look up an entry in m_auxids. More...

Friends
class	AuxTypeRegistryImpl

Detailed Description

Handle mappings between names and auxid_t.

Each auxiliary data item associated with a container has a name. Internally, they are identified by small integers of type auxid_t. This class handles the mapping between names and auxid_t's. It also keeps track of the type of each aux data item, and provides some generic methods for operating on this data.

The auxid_t namespace is global, shared among all classes. It's no problem for two classes to use aux data with the same auxid_t, as long as the type is the same. If they want to define them as different types, though, that's a problem. To help with this, an optional class name may be supplied; this qualifies the aux data name to make it unique across classes.

This class is meant to be used as a singleton. Use the instance method to get the singleton instance.

Methods are locked internally as needed, so access is thread-safe. Thread-safety is however not supported in standalone builds.

Definition at line 60 of file AuxTypeRegistry.h.

Member Typedef Documentation

◆ Flags

using SG::AuxTypeRegistry::Flags = SG::AuxVarFlags

Additional flags to qualify an auxiliary variable.

Definition at line 65 of file AuxTypeRegistry.h.

◆ lock_t

typedef AthContainers_detail::lock_guard<mutex_t> SG::AuxTypeRegistry::lock_t

private

Definition at line 541 of file AuxTypeRegistry.h.

◆ mutex_t

typedef AthContainers_detail::mutex SG::AuxTypeRegistry::mutex_t

private

Definition at line 540 of file AuxTypeRegistry.h.

Constructor & Destructor Documentation

◆ AuxTypeRegistry() [1/2]

SG::AuxTypeRegistry::AuxTypeRegistry ( )

private

Constructor.

Populates the type -> factory mappings for standard C++ types.

Definition at line 1212 of file AuxTypeRegistry.cxx.

1213 {

1214 }

◆ ~AuxTypeRegistry()

SG::AuxTypeRegistry::~AuxTypeRegistry ( )

private

Destructor.

Definition at line 1220 of file AuxTypeRegistry.cxx.

1221 {

1222 }

◆ AuxTypeRegistry() [2/2]

SG::AuxTypeRegistry::AuxTypeRegistry ( const AuxTypeRegistry & )

private

Disallow copy construction and assignment.

Member Function Documentation

◆ addFactory() [1/2]

const IAuxTypeVectorFactory * SG::AuxTypeRegistry::addFactory	(	const std::type_info &	ti,
		const std::string &	ti_alloc_name,
		std::unique_ptr< const IAuxTypeVectorFactory >	factory
	)

Add a new type -> factory mapping.

Parameters

ti	Type of the vector element.
ti_alloc_name	The name of the vector allocator type.
factory	The factory instance.

This records that factory can be used to construct vectors with an element type of ti. If a mapping already exists, the new factory is discarded, unless the old one is a dynamic factory and the new one isn't, in which case the new replaces the old one.

Definition at line 1197 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<AuxTypeRegistryImpl*> (this);
   lock_t lock (impl->m_mutex);
   return impl->addFactory (lock, ti, ti_alloc_name, std::move (factory));
 }

◆ addFactory() [2/2]

const IAuxTypeVectorFactory * SG::AuxTypeRegistry::addFactory	(	const std::type_info &	ti,
		const std::type_info &	ti_alloc,
		std::unique_ptr< const IAuxTypeVectorFactory >	factory
	)

Add a new type -> factory mapping.

Parameters

ti	Type of the vector element.
ti_alloc	The type of the vector allocator
factory	The factory instance.

This records that factory can be used to construct vectors with an element type of ti. If a mapping already exists, the new factory is discarded, unless the old one is a dynamic factory and the new one isn't, in which case the new replaces the old one.

Definition at line 1172 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<AuxTypeRegistryImpl*> (this);
   lock_t lock (impl->m_mutex);
   std::string name = SG::normalizedTypeinfoName (ti_alloc);
   const IAuxTypeVectorFactory* fac =
     impl->addFactory (lock, ti, name, std::move(factory));
   return impl->addFactory (lock, ti, ti_alloc, fac);
 }

◆ checkAuxID() [1/2]

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

void SG::AuxTypeRegistry::checkAuxID	(	const SG::auxid_t	auxid,
		const Flags	flags = `Flags::None`
	)

Verify type for an aux variable.

Parameters

auxid	The ID of the variable to check.
flags	Optional flags qualifying the type. See above.

If the type of auxid is not compatible with the supplied types T / ALLOC, then throw a SG::ExcAuxTypeMismatch exception. Also may throw SG::ExcFlagMismatch.

◆ checkAuxID() [2/2]

void SG::AuxTypeRegistry::checkAuxID	(	const SG::auxid_t	auxid,
		const std::type_info &	ti,
		const std::type_info &	ti_alloc,
		const Flags	flags
	)

Verify type for an aux variable.

Parameters

auxid	The ID of the variable to check.
ti	Type of the aux data item.
ti_alloc	Type of the vector allocator.
flags	Optional flags qualifying the type. See above.

If the type of auxid is not compatible with the supplied types ti / ti_alloc, then throw a SG::ExcAuxTypeMismatch exception. Also may throw SG::ExcFlagMismatch.

Definition at line 786 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<AuxTypeRegistryImpl*> (this);
   AuxTypeRegistryImpl::typeinfo_t& m = impl->m_types.at (auxid);
  
   if ( ! ((&ti == m.m_ti || strcmp(ti.name(), m.m_ti->name()) == 0) &&
           m.checkAlloc (&ti_alloc, nullptr)))
   {
     throw SG::ExcAuxTypeMismatch (auxid, ti, *m.m_ti,
                                   SG::normalizedTypeinfoName (ti_alloc),
                                   m.m_alloc_name);
   }
   if ((CxxUtils::test (m.m_flags, Flags::Atomic) &&
        !CxxUtils::test (flags, Flags::Atomic)) ||
       (CxxUtils::test (m.m_flags, Flags::Linked) != CxxUtils::test (flags, Flags::Linked)))
   {
     throw SG::ExcFlagMismatch (auxid, ti, m.m_flags, flags);
   }
 }

◆ classNameHasLink()

bool SG::AuxTypeRegistry::classNameHasLink ( const std::string & className )

static

Test to see if a class name corresponds to a class with a linked variable.

Definition at line 1312 of file AuxTypeRegistry.cxx.

 {
   if (className.find ("SG::JaggedVecElt<") != std::string::npos) {
     return true;
   }
   if (className.find ("SG::PackedLink<") != std::string::npos) {
     return true;
   }
   return false;
 }

◆ clear()

void SG::AuxTypeRegistry::clear	(	SG::auxid_t	auxid,
		AuxVectorData &	dst,
		size_t	dst_index,
		size_t	n
	)		const

Clear a range of elements within a vector.

Parameters

auxid	The aux data item being operated on.
dst	Container holding the element
dst_index	Index of the first element in the vector.
n	Number of elements to clear.

Definition at line 1091 of file AuxTypeRegistry.cxx.

 {
   const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
   if (factory)
     factory->clear (auxid, dst, dst_index, n);
 }

◆ copy() [1/2]

void SG::AuxTypeRegistry::copy	(	SG::auxid_t	auxid,
		AuxVectorData &&	dst,
		size_t	dst_index,
		const AuxVectorData &	src,
		size_t	src_index,
		size_t	n
	)		const

Copy elements between vectors.

Parameters

auxid	The aux data item being operated on.
dst	Container for the destination vector. Declared as a rvalue reference to allow passing a temporary here (such as from AuxVectorInterface).
dst_index	Index of the first destination element in the vector.
src	Container for the source vector.
src_index	Index of the first source element in the vector.
n	Number of elements to copy.

dst and @ src can be either the same or different.

◆ copy() [2/2]

void SG::AuxTypeRegistry::copy	(	SG::auxid_t	auxid,
		AuxVectorData &	dst,
		size_t	dst_index,
		const AuxVectorData &	src,
		size_t	src_index,
		size_t	n
	)		const

Copy elements between vectors.

Parameters

auxid	The aux data item being operated on.
dst	Container for the destination vector.
dst_index	Index of the first destination element in the vector.
src	Container for the source vector.
src_index	Index of the first source element in the vector.
n	Number of elements to copy.

dst and @ src can be either the same or different.

Definition at line 1026 of file AuxTypeRegistry.cxx.

 {
   const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
   if (factory)
     factory->copy (auxid, dst, dst_index, src, src_index, n);
 }

◆ copyForOutput()

void SG::AuxTypeRegistry::copyForOutput	(	SG::auxid_t	auxid,
		AuxVectorData &	dst,
		size_t	dst_index,
		const AuxVectorData &	src,
		size_t	src_index,
		size_t	n
	)		const

Copy elements between vectors.

Apply any transformations needed for output.

Parameters

auxid	The aux data item being operated on.
dst	Container for the destination vector.
dst_index	Index of the first destination element in the vector.
src	Container for the source vector.
src_index	Index of the first source element in the vector.
n	Number of elements to copy.

dst and @ src can be either the same or different.

Definition at line 1049 of file AuxTypeRegistry.cxx.

 {
   const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
   if (factory) {
     factory->copyForOutput (auxid, dst, dst_index, src, src_index, n);
   }
 }

◆ findAuxID()

SG::auxid_t SG::AuxTypeRegistry::findAuxID	(	const std::string &	name,
		const std::string &	clsname = `""`
	)		const

Look up a name -> auxid_t mapping.

Parameters

name	The name of the aux data item.
clsname	The name of its associated class. May be blank.

Will only find an existing auxid_t; unlike getAuxID, this won't make a new one. If the item isn't found, this returns null_auxid.

Definition at line 756 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
  
   // No locking needed here.
   // The extra test here is to avoid having to copy a string
   // in the common case where clsname is blank.
   AuxTypeRegistryImpl::id_map_t::const_iterator i =
     impl->m_auxids.find (clsname.empty() ?
                          name :
                          makeKey (name, clsname));
   if (i != impl->m_auxids.end()) {
     return i->second;
   }
   return null_auxid;
 }

◆ getAllocType()

const std::type_info * SG::AuxTypeRegistry::getAllocType ( SG::auxid_t auxid ) const

Return the type of the vector allocator.

Parameters

auxid The desired aux data item.

Definition at line 964 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
   if (auxid >= impl->m_types.size())
     return 0;
   return impl->m_types[auxid].m_ti_alloc;
 }

◆ getAuxID() [1/4]

SG::auxid_t SG::AuxTypeRegistry::getAuxID	(	const std::string &	alloc_type,
		const std::type_info &	ti,
		const std::string &	name,
		const std::string &	clsname = `""`,
		const Flags	flags = `Flags::None`,
		const SG::auxid_t	linkedVariable = `SG::null_auxid`
	)

Look up a name -> auxid_t mapping, specifying allocator.

Parameters

alloc_name	Name of the vector allocator type.
ti	Type of the aux data item.
name	The name of the aux data item.
clsname	The name of its associated class. May be blank.
flags	Optional flags qualifying the type. See above.
linkedVariable	auxid of a linked variable, or null_auxid.

The type of the item is given by ti. Return null_auxid if we don't know how to make vectors of ti. (Use addFactory to register additional types.) If an item with the same name was previously requested with a different type, then throw SG::ExcAuxTypeMismatch.

Definition at line 732 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<AuxTypeRegistryImpl*> (this);
   return impl->findAuxID (name, clsname, flags, linkedVariable,
                           ti, nullptr, &alloc_type,
                           &AuxTypeRegistry::makeFactoryNull);
 }

◆ getAuxID() [2/4]

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

SG::auxid_t SG::AuxTypeRegistry::getAuxID	(	const std::string &	name,
		const std::string &	clsname = `""`,
		const Flags	flags = `Flags::None`,
		const SG::auxid_t	linkedVariable = `SG::null_auxid`
	)

Look up a name -> auxid_t mapping.

Parameters

name	The name of the aux data item.
clsname	The name of its associated class. May be blank.
flags	Optional flags qualifying the type. See above.
linkedVariable	auxid of a linked variable, or null_auxid.

The type of the item is given by the template parameter T, and the ALLOC gives the type of the vector allocator. If an item with the same name was previously requested with a different type, then throw SG::ExcAuxTypeMismatch.

◆ getAuxID() [3/4]

SG::auxid_t SG::AuxTypeRegistry::getAuxID	(	const std::type_info &	ti,
		const std::string &	name,
		const std::string &	clsname = `""`,
		const Flags	flags = `Flags::None`,
		const SG::auxid_t	linkedVariable = `SG::null_auxid`
	)

Look up a name -> auxid_t mapping.

Parameters

ti	Type of the aux data item.
name	The name of the aux data item.
clsname	The name of its associated class. May be blank.
flags	Optional flags qualifying the type. See above.
linkedVariable	auxid of a linked variable, or null_auxid.

The type of the item is given by ti. Return null_auxid if we don't know how to make vectors of ti. (Use addFactory to register additional types.) If an item with the same name was previously requested with a different type, then throw SG::ExcAuxTypeMismatch.

Definition at line 672 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<AuxTypeRegistryImpl*> (this);
   return impl->findAuxID (name, clsname, flags, linkedVariable,
                           ti, nullptr, nullptr,
                           &AuxTypeRegistry::makeFactoryNull);
 }

◆ getAuxID() [4/4]

SG::auxid_t SG::AuxTypeRegistry::getAuxID	(	const std::type_info &	ti_alloc,
		const std::type_info &	ti,
		const std::string &	name,
		const std::string &	clsname = `""`,
		const Flags	flags = `Flags::None`,
		const SG::auxid_t	linkedVariable = `SG::null_auxid`,
		std::unique_ptr< IAuxTypeVectorFactory >(AuxTypeRegistry::*)() const	makeFactory = `&AuxTypeRegistry::makeFactoryNull`
	)

Look up a name -> auxid_t mapping, specifying allocator.

Parameters

ti_alloc	Type of the vector allocator.
ti	Type of the aux data item.
name	The name of the aux data item.
clsname	The name of its associated class. May be blank.
flags	Optional flags qualifying the type. See above.
linkedVariable	auxid of a linked variable, or null_auxid.
makeFactory	Function to create a factory for this type, if needed. May return 0 if the type is unknown.

The type of the item is given by ti. Return null_auxid if we don't know how to make vectors of ti. (Use addFactory to register additional types.) If an item with the same name was previously requested with a different type, then throw SG::ExcAuxTypeMismatch.

Definition at line 702 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<AuxTypeRegistryImpl*> (this);
   return impl->findAuxID (name, clsname, flags, linkedVariable,
                           ti, &ti_alloc, nullptr,
                           makeFactory);
 }

◆ getClassName()

std::string SG::AuxTypeRegistry::getClassName ( SG::auxid_t auxid ) const

Return the class name associated with an aux data item (may be blank).

Parameters

auxid The desired aux data item.

Definition at line 895 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
   if (auxid >= impl->m_types.size())
     return "";
   return impl->m_types[auxid].m_clsname;
 }

◆ getEltSize()

size_t SG::AuxTypeRegistry::getEltSize ( SG::auxid_t auxid ) const

Return size of an element in the STL vector.

Parameters

auxid The desired aux data item.

Definition at line 977 of file AuxTypeRegistry.cxx.

 {
   const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
   if (factory)
     return factory->getEltSize();
   return 0;
 }

◆ getFactory() [1/3]

const IAuxTypeVectorFactory * SG::AuxTypeRegistry::getFactory	(	const std::type_info &	ti,
		const std::string &	alloc_name
	)

Return the vector factory for a given vector element type.

Parameters

ti	The type of the vector element.
alloc_name	The name of the vector allocator type.

Returns nullptr if the type is not known. (Use addFactory to add new mappings.)

Definition at line 1145 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<AuxTypeRegistryImpl*> (this);
  
   std::string key = std::string (ti.name()) + ";" + alloc_name;
   AuxTypeRegistryImpl::ti_map_t::const_iterator it = impl->m_factories.find (key);
   if (it != impl->m_factories.end()) {
     return it->second;
   }
  
   return nullptr;
 }

◆ getFactory() [2/3]

const IAuxTypeVectorFactory * SG::AuxTypeRegistry::getFactory	(	const std::type_info &	ti,
		const std::type_info &	ti_alloc
	)

Return the vector factory for a given vector element type.

Parameters

ti	The type of the vector element.
ti_alloc	The type of the vector allocator.

Returns nullptr if the type is not known. (Use addFactory to add new mappings.)

Parameters

ti	The type of the vector element.
ti_alloc	The type of the vector allocator

Returns nullptr if the type is not known. (Use addFactory to add new mappings.)

Definition at line 1110 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<AuxTypeRegistryImpl*> (this);
   lock_t lock (impl->m_mutex);
   return impl->getFactory (lock, ti, ti_alloc);
 }

◆ getFactory() [3/3]

const IAuxTypeVectorFactory * SG::AuxTypeRegistry::getFactory ( SG::auxid_t auxid ) const

Return the vector factory for a given auxid.

Parameters

auxid The desired aux data item.

Returns nullptr if the type is not known. (Use addFactory to add new mappings.)

Definition at line 1127 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
   if (auxid >= impl->m_types.size())
     return 0;
   return impl->m_types[auxid].m_factory;
 }

◆ getFlags()

AuxVarFlags SG::AuxTypeRegistry::getFlags ( SG::auxid_t auxid ) const

Return flags associated with an auxiliary variable.

Parameters

auxid The desired aux data item.

Definition at line 990 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
   if (auxid >= impl->m_types.size())
     return Flags::None;
   return impl->m_types[auxid].m_flags;
 }

◆ getName()

std::string SG::AuxTypeRegistry::getName ( SG::auxid_t auxid ) const

Return the name of an aux data item.

Parameters

auxid The desired aux data item.

Definition at line 881 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
   if (auxid >= impl->m_types.size())
     return "";
   return impl->m_types[auxid].m_name;
 }

◆ getType()

const std::type_info * SG::AuxTypeRegistry::getType ( SG::auxid_t auxid ) const

Return the type of an aux data item.

Parameters

auxid The desired aux data item.

Definition at line 908 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
   if (auxid >= impl->m_types.size())
     return 0;
   return impl->m_types[auxid].m_ti;
 }

◆ getTypeName()

std::string SG::AuxTypeRegistry::getTypeName ( SG::auxid_t auxid ) const

Return the type name of an aux data item.

Parameters

auxid The desired aux data item.

Returns an empty string if the type is not known.

Definition at line 923 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
   if (auxid >= impl->m_types.size())
     return "";
   return normalizedTypeinfoName (*impl->m_types[auxid].m_ti);
 }

◆ getVecType()

const std::type_info * SG::AuxTypeRegistry::getVecType ( SG::auxid_t auxid ) const

Return the type of the STL vector used to hold an aux data item.

Parameters

auxid The desired aux data item.

Definition at line 936 of file AuxTypeRegistry.cxx.

 {
   const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
   if (factory)
     return factory->tiVec();
   return 0;
 }

◆ getVecTypeName()

std::string SG::AuxTypeRegistry::getVecTypeName ( SG::auxid_t auxid ) const

Return the type of the STL vector used to hold an aux data item.

Return the type name of the STL vector used to hold an aux data item.

Parameters

auxid The desired aux data item.

Returns an empty string if the type is not known.

Definition at line 951 of file AuxTypeRegistry.cxx.

 {
   const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
   if (factory)
     return normalizedTypeinfoName (*factory->tiVec());
   return "";
 }

◆ inputRename()

const std::string & SG::AuxTypeRegistry::inputRename	(	const std::string &	key,
		const std::string &	name
	)		const

Check for an input renaming of an auxiliary variable.

key The SG key of the object to which the variable is attached.

name The name of the variable on the input file.

Returns: The variable name to use in the transient representation. Will usually be name, but may be different if there was a renaming request.

Definition at line 1273 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
   lock_t lock (impl->m_mutex);
   if (impl->m_renameMap.empty())
     return name;
  
   std::string fullkey = key + "." + name;
   auto it = impl->m_renameMap.find (fullkey);
   if (it != impl->m_renameMap.end())
     return it->second;
   return name;
 }

◆ instance()

AuxTypeRegistry & SG::AuxTypeRegistry::instance ( )

static

Return the singleton registry instance.

Definition at line 639 of file AuxTypeRegistry.cxx.

 {
   static AuxTypeRegistryImpl auxTypeRegistry ATLAS_THREAD_SAFE;
   return auxTypeRegistry;
 }

◆ isLinked()

bool SG::AuxTypeRegistry::isLinked ( SG::auxid_t auxid ) const

Test whether this is a linked variable.

Parameters

auxid The aux data item to test.

◆ isLinkedName()

bool SG::AuxTypeRegistry::isLinkedName ( const std::string & name )

static

Test if a variable name corresponds to a linked variable.

Definition at line 1292 of file AuxTypeRegistry.cxx.

 {
   return name.ends_with ("_linked");
 }

◆ linkedName()

std::string SG::AuxTypeRegistry::linkedName ( const std::string & name )

static

Given a variable name, return the name of the corresponding linked variable.

Definition at line 1302 of file AuxTypeRegistry.cxx.

 {
   return name + "_linked";
 }

◆ linkedVariable()

SG::auxid_t SG::AuxTypeRegistry::linkedVariable ( SG::auxid_t auxid ) const

Return the auxid if the linked variable, if there is one.

Parameters

auxid The aux data item to test.

Returns null_auxid if auxid is invalid or it doesn't have a linked variable.

Definition at line 1006 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
   if (auxid >= impl->m_types.size())
     return null_auxid;
   return impl->m_types[auxid].m_linked;
 }

◆ makeFactory()

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

std::unique_ptr<IAuxTypeVectorFactory> SG::AuxTypeRegistry::makeFactory ( ) const

private

Create an AuxTypeVectorFactory instance.

This is passed to findAuxID when we're looking up an item for which we know the type at compile-time.

The ALLOC template parameter is the allocator to use for the resulting vector.

◆ makeFactoryNull()

std::unique_ptr<IAuxTypeVectorFactory> SG::AuxTypeRegistry::makeFactoryNull ( ) const

private

makeFactory implementation that always returns nullptr.

This is passed to findAuxID when we're looking up an item for which we do not know the type at compile-time.

◆ makeKey()

std::string SG::AuxTypeRegistry::makeKey	(	const std::string &	name,
		const std::string &	clsname
	)

staticprivate

Return the key used to look up an entry in m_auxids.

Parameters

name	The name of the aux data item.
clsname	The name of its associated class. May be blank.

Definition at line 863 of file AuxTypeRegistry.cxx.

 {
   if (clsname.empty()) {
     return name;
   }
   std::string output = clsname;
   output += "::";
   output += name;
   return output;
 }

◆ makeVector()

std::unique_ptr< IAuxTypeVector > SG::AuxTypeRegistry::makeVector	(	SG::auxid_t	auxid,
		size_t	size,
		size_t	capacity
	)		const

Construct a new vector to hold an aux item.

Parameters

auxid	The desired aux data item.
size	Initial size of the new vector.
capacity	Initial capacity of the new vector.

Returns a newly-allocated object.

Parameters

auxid	The desired aux data item.
size	Initial size of the new vector.
capacity	Initial capacity of the new vector.

Definition at line 817 of file AuxTypeRegistry.cxx.

 {
   const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
   assert (factory != 0);
   return factory->create (auxid, size, capacity, isLinked (auxid));
 }

◆ makeVectorFromData()

std::unique_ptr< IAuxTypeVector > SG::AuxTypeRegistry::makeVectorFromData	(	SG::auxid_t	auxid,
		void *	data,
		IAuxTypeVector *	linkedVector,
		bool	isPacked,
		bool	ownMode
	)		const

Construct an IAuxTypeVector object from a vector.

Parameters

data	The vector object.
linkedVector	The interface for another variable linked to this one, or nullptr if there isn't one. (We do not take ownership.)
isPacked	If true, `data` is a `PackedContainer`.
ownFlag	If true, the newly-created IAuxTypeVector object will take ownership of `data`.

If the element type is T, then data should be a pointer to a std::vector<T> object, which was obtained with new. But if isPacked is true, then data should instead point at an object of type SG::PackedContainer<T>.

Returns a newly-allocated object.

Definition at line 845 of file AuxTypeRegistry.cxx.

 {
   const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
   assert (factory != 0);
   return factory->createFromData (auxid, data, linkedVector,
                                   isPacked, ownMode, isLinked (auxid));
 }

◆ numVariables()

size_t SG::AuxTypeRegistry::numVariables ( ) const

Return the total number of registered auxiliary variable.

(This will be one more than the current largest auxid.)

Definition at line 651 of file AuxTypeRegistry.cxx.

 {
   auto* impl = static_cast<const AuxTypeRegistryImpl*> (this);
   return impl->m_types.size();
 }

◆ operator=()

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

private

◆ setInputRenameMap()

void SG::AuxTypeRegistry::setInputRenameMap	(	const Athena::InputRenameMap_t *	map,
		const IStringPool &	pool
	)

Declare input renaming requests.

Parameters

map	Map of (hashed) sgkey -> sgkey for renaming requests.
pool	String pool in which the hashed keys are defined.

This is called by AddressRemappingSvc when there is a request to rename input objects. It saves any requests involving renaming of auxiliary variables and makes that information available via inputRename.

Definition at line 1237 of file AuxTypeRegistry.cxx.

 {
   auto impl = static_cast<AuxTypeRegistryImpl*> (this);
  
   lock_t lock (impl->m_mutex);
   impl->m_renameMap.clear();
   if (!map) return;
   for (const auto& p : *map) {
     sgkey_t from_sgkey = p.first;
     sgkey_t to_sgkey = p.second.m_sgkey;
  
     const std::string* from_str = pool.keyToString (from_sgkey);
     if (!from_str) continue;
     std::string::size_type from_dpos = from_str->find (".");
     if (from_dpos == std::string::npos || from_dpos == from_str->size()-1) continue;
  
     const std::string* to_str = pool.keyToString (to_sgkey);
     if (!to_str) continue;
     std::string::size_type to_dpos = to_str->find (".");
     if (to_dpos == std::string::npos || to_dpos == to_str->size()-1) continue;
  
     impl->m_renameMap[*from_str] = to_str->substr (to_dpos+1, std::string::npos);
   }
 }

◆ swap()

void SG::AuxTypeRegistry::swap	(	SG::auxid_t	auxid,
		AuxVectorData &	a,
		size_t	aindex,
		AuxVectorData &	b,
		size_t	bindex,
		size_t	n
	)		const

Swap elements between vectors.

Parameters

auxid	The aux data item being operated on.
a	Container for the first vector.
aindex	Index of the first element in the first vector.
b	Container for the second vector.
bindex	Index of the first element in the second vector.
n	Number of elements to swap.

a and @ b can be either the same or different. However, the ranges should not overlap.

Definition at line 1073 of file AuxTypeRegistry.cxx.

 {
   const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
   if (factory)
     factory->swap (auxid, a, aindex, b, bindex, n);
 }

Friends And Related Function Documentation

◆ AuxTypeRegistryImpl

friend class AuxTypeRegistryImpl

friend

Definition at line 538 of file AuxTypeRegistry.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ Flags

◆ lock_t

◆ mutex_t

Constructor & Destructor Documentation

◆ AuxTypeRegistry() [1/2]

◆ ~AuxTypeRegistry()

◆ AuxTypeRegistry() [2/2]

Member Function Documentation

◆ addFactory() [1/2]

◆ addFactory() [2/2]

◆ checkAuxID() [1/2]

◆ checkAuxID() [2/2]

◆ classNameHasLink()

◆ clear()

◆ copy() [1/2]

◆ copy() [2/2]

◆ copyForOutput()

◆ findAuxID()

◆ getAllocType()

◆ getAuxID() [1/4]

◆ getAuxID() [2/4]

◆ getAuxID() [3/4]

◆ getAuxID() [4/4]

◆ getClassName()

◆ getEltSize()

◆ getFactory() [1/3]

◆ getFactory() [2/3]

◆ getFactory() [3/3]

◆ getFlags()

◆ getName()

◆ getType()

◆ getTypeName()

◆ getVecType()

◆ getVecTypeName()

◆ inputRename()

◆ instance()

◆ isLinked()

◆ isLinkedName()

◆ linkedName()

◆ linkedVariable()

◆ makeFactory()

◆ makeFactoryNull()

◆ makeKey()

◆ makeVector()

◆ makeVectorFromData()

◆ numVariables()

◆ operator=()

◆ setInputRenameMap()

◆ swap()

Friends And Related Function Documentation

◆ AuxTypeRegistryImpl