Handle mappings between names and auxid_t. More...

#include <AuxTypeRegistry.h>

Collaboration diagram for SG::AuxTypeRegistry:

Classes
struct	typeinfo_t
	Hold information about one aux data item. More...

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

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::IInputRename::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...

Private Types
typedef AthContainers_detail::mutex	mutex_t

typedef AthContainers_detail::lock_guard< mutex_t >	lock_t

using	id_map_t = CxxUtils::ConcurrentStrMap< SG::auxid_t, CxxUtils::SimpleUpdater >
	Map from name -> auxid. More...

using	ti_map_t = CxxUtils::ConcurrentStrMap< const IAuxTypeVectorFactory *, CxxUtils::SimpleUpdater >
	Map from type_info name + allocator ti name -> IAuxTypeVectorFactory. More...

typedef std::unordered_map< std::string, std::string >	renameMap_t
	Save the information provided by `setInputRenameMap`. More...

using	allocMap_t = CxxUtils::ConcurrentStrMap< const std::type_info *, CxxUtils::SimpleUpdater >

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

	~AuxTypeRegistry ()
	Destructor. More...

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

AuxTypeRegistry &	operator= (const AuxTypeRegistry &)

SG::auxid_t	findAuxID (const std::string &name, const std::string &clsname, const Flags flags, const std::type_info &ti, const std::type_info ti_alloc, const std::string alloc_name, std::unique_ptr< IAuxTypeVectorFactory >(AuxTypeRegistry::*makeFactory)() const)
	Look up a name -> `auxid_t` mapping. More...

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

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

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

const IAuxTypeVectorFactory *	getFactory (lock_t &lock, const std::type_info &ti, const std::type_info &ti_alloc)
	Return the vector factory for a given vector element type. 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...

static bool	checkName (const std::string &s)
	Check for valid variable name. More...

Private Attributes
AthContainers_detail::concurrent_vector< typeinfo_t >	m_types
	Table of aux data items, indexed by `auxid`. More...

id_map_t	m_auxids

ti_map_t	m_factories

std::vector< const IAuxTypeVectorFactory * >	m_oldFactories
	Hold additional factory instances we need to delete. More...

renameMap_t	m_renameMap

mutex_t	m_mutex
	Mutex controlling access to the registry. More...

allocMap_t	m_allocMap

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 61 of file AuxTypeRegistry.h.

Member Typedef Documentation

◆ allocMap_t

using SG::AuxTypeRegistry::allocMap_t = CxxUtils::ConcurrentStrMap<const std::type_info*, CxxUtils::SimpleUpdater>

private

Definition at line 701 of file AuxTypeRegistry.h.

◆ Flags

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

Additional flags to qualify an auxiliary variable.

Definition at line 66 of file AuxTypeRegistry.h.

◆ id_map_t

using SG::AuxTypeRegistry::id_map_t = CxxUtils::ConcurrentStrMap<SG::auxid_t, CxxUtils::SimpleUpdater>

private

Map from name -> auxid.

Definition at line 675 of file AuxTypeRegistry.h.

◆ lock_t

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

private

Definition at line 488 of file AuxTypeRegistry.h.

◆ mutex_t

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

private

Definition at line 487 of file AuxTypeRegistry.h.

◆ renameMap_t

typedef std::unordered_map<std::string, std::string> SG::AuxTypeRegistry::renameMap_t

private

Save the information provided by setInputRenameMap.

Each entry is of the form KEY.DECOR -> DECOR_RENAMED

Definition at line 687 of file AuxTypeRegistry.h.

◆ ti_map_t

using SG::AuxTypeRegistry::ti_map_t = CxxUtils::ConcurrentStrMap<const IAuxTypeVectorFactory*, CxxUtils::SimpleUpdater>

private

Map from type_info name + allocator ti name -> IAuxTypeVectorFactory.

Definition at line 679 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 653 of file AuxTypeRegistry.cxx.

   : m_auxids (id_map_t::Updater_t()),
     m_factories (ti_map_t::Updater_t()),
     m_allocMap (allocMap_t::Updater_t())
 {
   m_types.reserve (auxid_set_size_hint);
  
   // Make sure we have factories registered for common C++ types.
 #define ADD_FACTORY(T) addFactory(typeid(T), typeid(AuxAllocator_t<T>), std::make_unique<AuxTypeVectorFactory<T> >())
   ADD_FACTORY (bool);
   ADD_FACTORY (char);
   ADD_FACTORY (unsigned char);
   ADD_FACTORY (short);
   ADD_FACTORY (unsigned short);
   ADD_FACTORY (int);
   ADD_FACTORY (unsigned int);
   ADD_FACTORY (long);
   ADD_FACTORY (unsigned long);
   ADD_FACTORY (long long);
   ADD_FACTORY (unsigned long long);
   ADD_FACTORY (float);
   ADD_FACTORY (double);
   ADD_FACTORY (std::string);
  
   ADD_FACTORY (std::vector<char>);
   ADD_FACTORY (std::vector<unsigned char>);
   ADD_FACTORY (std::vector<int>);
   ADD_FACTORY (std::vector<unsigned int>);
   ADD_FACTORY (std::vector<float>);
   ADD_FACTORY (std::vector<double>);
 #undef ADD_FACTORY
 }

◆ ~AuxTypeRegistry()

SG::AuxTypeRegistry::~AuxTypeRegistry ( )

private

Destructor.

Delete factory instances.

Definition at line 692 of file AuxTypeRegistry.cxx.

 {
   // not using reference, because our iterator doesn't return a reference
   for (auto p : m_factories) {
     if (p.first.find (";TI;") == std::string::npos) {
       delete p.second;
     }
   }
   for (const IAuxTypeVectorFactory* p : m_oldFactories)
     delete p;
 }

◆ AuxTypeRegistry() [2/2]

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

private

Disallow copy construction and assignment.

Member Function Documentation

◆ addFactory() [1/4]

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 554 of file AuxTypeRegistry.cxx.

 {
   lock_t lock (m_mutex);
   return addFactory (lock, ti, ti_alloc_name, std::move (factory));
 }

◆ addFactory() [2/4]

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 530 of file AuxTypeRegistry.cxx.

 {
   lock_t lock (m_mutex);
   std::string name = SG::normalizedTypeinfoName (ti_alloc);
   const IAuxTypeVectorFactory* fac =
     addFactory (lock, ti, name, std::move(factory));
   return addFactory (lock, ti, ti_alloc, fac);
 }

◆ addFactory() [3/4]

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

private

Add a new type -> factory mapping.

(external locking)

Parameters

lock	The registry lock.
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 619 of file AuxTypeRegistry.cxx.

 {
   std::string key = std::string (ti.name()) + ";" + ti_alloc_name;
   ti_map_t::const_iterator it = m_factories.find (key);
   const IAuxTypeVectorFactory* fac = factory.get();
   if (it != m_factories.end()) {
     if (it->second->isDynamic() && !factory->isDynamic()) {
       // Replacing a dynamic factory with a non-dynamic one.
       // But don't delete the old one, since it might still be referenced.
       // Instead, push it on a vector to remember it so we can delete
       // it later.
       m_oldFactories.push_back (it->second);
       m_factories.insert_or_assign (key, factory.release());
     }
     else {
       fac = it->second;
     }
   }
   else
     m_factories.insert_or_assign (key, factory.release());
  
   // cppcheck-suppress returnDanglingLifetime; false positive
   return fac;
 }

◆ addFactory() [4/4]

const IAuxTypeVectorFactory * SG::AuxTypeRegistry::addFactory	(	lock_t &	lock,
		const std::type_info &	ti,
		const std::type_info &	ti_alloc,
		const IAuxTypeVectorFactory *	factory
	)

private

Add a new type -> factory mapping.

(external locking)

Parameters

lock	The registry lock.
ti	Type of the vector element.
ti_alloc	The type of the vector allocator
factory	The factory instance. Ownership is not taken.

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 576 of file AuxTypeRegistry.cxx.

 {
   std::string key = std::string (ti.name()) + ";TI;" + ti_alloc.name();
   ti_map_t::const_iterator it = m_factories.find (key);
   if (it != m_factories.end()) {
     if (it->second->isDynamic() && !factory->isDynamic()) {
       // Replacing a dynamic factory with a non-dynamic one.
       // The string version should put it to m_oldFactories.
       m_factories.insert_or_assign (key, factory);
     }
     else {
       factory = it->second;
     }
   }
   else
     m_factories.insert_or_assign (key, factory);
  
   if (SG::normalizedTypeinfoName (ti_alloc).starts_with(
                           SG::auxAllocatorNamePrefix))
   {
     m_allocMap.insert_or_assign (ti.name(), &ti_alloc);
   }
  
   return factory;
 }

◆ 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::ExcAtomicMismatch.

◆ 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::ExcAtomicMismatch.

Definition at line 177 of file AuxTypeRegistry.cxx.

 {
   typeinfo_t& m = 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))
   {
     throw SG::ExcAtomicMismatch (auxid, ti);
   }
 }

◆ checkName()

bool SG::AuxTypeRegistry::checkName ( const std::string & s )

staticprivate

Check for valid variable name.

Parameters

name	Name to check.

Require that NAME be not empty, contains only alphanumeric characters plus underscore, and first character is not a digit.

Definition at line 929 of file AuxTypeRegistry.cxx.

 {
   static const std::string chars1 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_";
   static const std::string chars2 = chars1 + "0123456789";
  
   if (s.empty()) return false;
   if (chars1.find (s[0]) == std::string::npos) return false;
   return s.find_first_not_of (chars2, 1) == std::string::npos;
 }

◆ 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 438 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 373 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 396 of file AuxTypeRegistry.cxx.

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

◆ findAuxID() [1/2]

SG::auxid_t SG::AuxTypeRegistry::findAuxID	(	const std::string &	name,
		const std::string &	clsname,
		const Flags	flags,
		const std::type_info &	ti,
		const std::type_info *	ti_alloc,
		const std::string *	alloc_name,
		std::unique_ptr< IAuxTypeVectorFactory >(AuxTypeRegistry::*)() const	makeFactory
	)

private

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.
ti	The type of this aux data item.
ti_alloc	The type of the vector allocator.
alloc_name	The name of the vector allocator. Used only if ti_alloc is null.
makeFactory	Function to create a factory for this type, if needed. May return 0 if the type is unknown.

If the aux data item already exists, check to see if the provided type matches the type that was used before. If so, then set return the auxid; otherwise, throw SG::ExcAuxTypeMismatch.

If the aux data item does not already exist, then see if we have a factory registered for this type_info. If not, then call makeFactory and use what it returns. If that returns 0, then fail and return null_auxid. Otherwise, assign a new auxid and return it.

Definition at line 729 of file AuxTypeRegistry.cxx.

 {
  
   // The extra test here is to avoid having to copy a string
   // in the common case where clsname is blank.
   const std::string& key = clsname.empty() ? name : makeKey (name, clsname);
  
  
   // Fast path --- try without acquiring the lock.
   {
     id_map_t::const_iterator i = m_auxids.find (key);
     if (i != m_auxids.end()) {
       typeinfo_t& m = m_types[i->second];
       if (!(CxxUtils::test (m.m_flags, Flags::Atomic) &&
             !CxxUtils::test (flags, Flags::Atomic)) &&
           (&ti == m.m_ti || strcmp(ti.name(), m.m_ti->name()) == 0) &&
           m.checkAlloc (ti_alloc, alloc_name) &&
           !(*m.m_factory).isDynamic())
       {
         return i->second;
       }
     }
   }
  
   // Something went wrong.  Acquire the lock and try again.
   lock_t lock (m_mutex);
   id_map_t::const_iterator i = m_auxids.find (key);
   if (i != m_auxids.end()) {
     typeinfo_t& m = m_types[i->second];
  
     if (CxxUtils::test (m.m_flags, Flags::Atomic) &&
         !CxxUtils::test (flags, Flags::Atomic))
     {
       throw SG::ExcAtomicMismatch (i->second, ti);
     }
  
     // By all rights, these two tests should be redundant.
     // However, there are cases where we see distinct @c type_info objects
     // for the same type.  This is usually associated with dictionaries
     // being loaded `too early,' during python configuration processing.
     // It's a C++ standard violation for this to ever happen, but it's
     // not clear that it's feasible to actually eliminate the possibility
     // of this happening.  So if the @c type_info instances differ,
     // we still accept the match as long as the names are the same.
     if ((&ti == m.m_ti || strcmp(ti.name(), m.m_ti->name()) == 0) &&
         m.checkAlloc (ti_alloc, alloc_name))
     {
       // Try to upgrade a dynamic factory.
       if ((*m.m_factory).isDynamic()) {
         std::unique_ptr<IAuxTypeVectorFactory> fac2 = (*this.*makeFactory)();
         if (fac2) {
           if (!ti_alloc) {
             ti_alloc = fac2->tiAlloc();
           }
           std::string allocName = fac2->tiAllocName();
           m.m_factory = addFactory (lock, ti, allocName, std::move (fac2));
           if (ti_alloc) {
             m.m_factory = addFactory (lock, ti, *ti_alloc, m.m_factory);
           }
         }
       }
       return i->second;
     }
     if( *m.m_ti != typeid(SG::AuxTypePlaceholder) ) {
       throw SG::ExcAuxTypeMismatch (i->second, ti, *m.m_ti,
                                     ti_alloc ? SG::normalizedTypeinfoName (*ti_alloc) : (alloc_name ? *alloc_name : ""),
                                     m.m_alloc_name);
     }
     // fall through, get a new auxid and real type info
     // new auxid needed so a new data vector is created in the AuxStore
   }
  
   // Verify now that the variable names are ok.
   if (!(flags & Flags::SkipNameCheck) &&
       (!checkName (name) ||
        (!clsname.empty() && !checkName (clsname))))
   {
     throw ExcBadVarName (key);
   }
  
   const IAuxTypeVectorFactory* fac = nullptr;
   if (ti_alloc) {
     fac = getFactory (lock, ti, *ti_alloc);
   }
   else if (alloc_name) {
     fac = getFactory (ti, *alloc_name);
   }
   else {
     std::string def_alloc_name = SG::auxAllocatorNamePrefix + SG::normalizedTypeinfoName (ti);
     if (def_alloc_name[def_alloc_name.size()-1] == '>') def_alloc_name += " ";
     def_alloc_name += ">";
     fac = getFactory (ti,def_alloc_name);
   }
  
   if (!fac || fac->isDynamic()) {
     std::unique_ptr<IAuxTypeVectorFactory> fac2 = (*this.*makeFactory)();
     if (fac2) {
       if (!ti_alloc) {
         ti_alloc = fac2->tiAlloc();
       }
       std::string allocName = fac2->tiAllocName();
       fac = addFactory (lock, ti, allocName, std::move (fac2));
       if (ti_alloc) {
         fac = addFactory (lock, ti, *ti_alloc, fac);
       }
     }
   }
   if (!fac) return null_auxid;
   if (!ti_alloc) ti_alloc = fac->tiAlloc();
   SG::auxid_t auxid = m_types.size();
   m_types.resize (auxid+1);
   typeinfo_t& t = m_types[auxid];
   t.m_name = name;
   t.m_clsname = clsname;
   t.m_ti = &ti;
   t.m_ti_alloc = ti_alloc;
   t.m_alloc_name = fac->tiAllocName();
   t.m_factory = fac;
   t.m_flags = (flags & ~Flags::SkipNameCheck);
   AthContainers_detail::fence_seq_cst();
   m_auxids.insert_or_assign (key, auxid);
  
   return auxid;
 }

◆ findAuxID() [2/2]

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 150 of file AuxTypeRegistry.cxx.

 {
   // No locking needed here.
   // The extra test here is to avoid having to copy a string
   // in the common case where clsname is blank.
   id_map_t::const_iterator i = m_auxids.find (clsname.empty() ?
                                               name :
                                               makeKey (name, clsname));
   if (i != 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 341 of file AuxTypeRegistry.cxx.

 {
   if (auxid >= m_types.size())
     return 0;
   return 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`
	)

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.

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 129 of file AuxTypeRegistry.cxx.

 {
   return findAuxID (name, clsname, flags, 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`
	)

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.

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

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.

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 80 of file AuxTypeRegistry.cxx.

 {
   return findAuxID (name, clsname, flags, 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`
	)

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.

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 104 of file AuxTypeRegistry.cxx.

 {
   return findAuxID (name, clsname, flags, ti, &ti_alloc, nullptr,
                     &AuxTypeRegistry::makeFactoryNull);
 }

◆ 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 275 of file AuxTypeRegistry.cxx.

 {
   if (auxid >= m_types.size())
     return "";
   return 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 353 of file AuxTypeRegistry.cxx.

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

◆ getFactory() [1/4]

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 505 of file AuxTypeRegistry.cxx.

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

◆ getFactory() [2/4]

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 457 of file AuxTypeRegistry.cxx.

 {
   lock_t lock (m_mutex);
   return getFactory (lock, ti, ti_alloc);
 }

◆ getFactory() [3/4]

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

private

Return the vector factory for a given vector element type.

(External locking.)

Parameters

lock	The registry lock.
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 476 of file AuxTypeRegistry.cxx.

 {
   std::string key = std::string (ti.name()) + ";TI;" + ti_alloc.name();
   ti_map_t::const_iterator it = m_factories.find (key);
   if (it != m_factories.end())
     return it->second;
  
   std::string name = SG::normalizedTypeinfoName (ti_alloc);
   const IAuxTypeVectorFactory* fac = getFactory (ti, name);
   if (fac) {
     // We only really need to be holding the lock here, but doing things
     // otherwise would require some code duplication.
     addFactory (lock, ti, ti_alloc, fac);
   }
   return fac;
 }

◆ getFactory() [4/4]

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

◆ getFlags()

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

Return flags associated with an auxiliary variable.

Parameters

auxid The desired aux data item.

◆ 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 262 of file AuxTypeRegistry.cxx.

 {
   if (auxid >= m_types.size())
     return "";
   return 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 287 of file AuxTypeRegistry.cxx.

 {
   if (auxid >= m_types.size())
     return 0;
   return 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 301 of file AuxTypeRegistry.cxx.

 {
   if (auxid >= m_types.size())
     return "";
   return normalizedTypeinfoName (*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 313 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 328 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 907 of file AuxTypeRegistry.cxx.

 {
   lock_t lock (m_mutex);
   if (m_renameMap.empty())
     return name;
  
   std::string fullkey = key + "." + name;
   renameMap_t::const_iterator it = m_renameMap.find (fullkey);
   if (it != m_renameMap.end())
     return it->second;
   return name;
 }

◆ instance()

AuxTypeRegistry & SG::AuxTypeRegistry::instance ( )

static

Return the singleton registry instance.

Definition at line 49 of file AuxTypeRegistry.cxx.

 {
   static AuxTypeRegistry auxTypeRegistry ATLAS_THREAD_SAFE;
   return auxTypeRegistry;
 }

◆ 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 247 of file AuxTypeRegistry.cxx.

 {
   if (clsname.empty()) {
     return name;
   }
   return clsname + "::" + name;
 }

◆ 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 206 of file AuxTypeRegistry.cxx.

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

◆ makeVectorFromData()

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

Construct an IAuxTypeVector object from a vector.

Parameters

data	The vector object.
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 231 of file AuxTypeRegistry.cxx.

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

◆ 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 61 of file AuxTypeRegistry.cxx.

 {
   return m_types.size();
 }

◆ operator=()

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

private

◆ setInputRenameMap()

void SG::AuxTypeRegistry::setInputRenameMap	(	const Athena::IInputRename::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 873 of file AuxTypeRegistry.cxx.

 {
   lock_t lock (m_mutex);
   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;
  
     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 420 of file AuxTypeRegistry.cxx.

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

Member Data Documentation

◆ m_allocMap

allocMap_t SG::AuxTypeRegistry::m_allocMap

private

Definition at line 702 of file AuxTypeRegistry.h.

◆ m_auxids

id_map_t SG::AuxTypeRegistry::m_auxids

private

Definition at line 676 of file AuxTypeRegistry.h.

◆ m_factories

ti_map_t SG::AuxTypeRegistry::m_factories

private

Definition at line 680 of file AuxTypeRegistry.h.

◆ m_mutex

mutex_t SG::AuxTypeRegistry::m_mutex

mutableprivate

Mutex controlling access to the registry.

Definition at line 696 of file AuxTypeRegistry.h.

◆ m_oldFactories

std::vector<const IAuxTypeVectorFactory*> SG::AuxTypeRegistry::m_oldFactories

private

Hold additional factory instances we need to delete.

Definition at line 683 of file AuxTypeRegistry.h.

◆ m_renameMap

renameMap_t SG::AuxTypeRegistry::m_renameMap

private

Definition at line 688 of file AuxTypeRegistry.h.

◆ m_types

AthContainers_detail::concurrent_vector<typeinfo_t> SG::AuxTypeRegistry::m_types

private

Table of aux data items, indexed by auxid.

Definition at line 671 of file AuxTypeRegistry.h.

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ allocMap_t

◆ Flags

◆ id_map_t

◆ lock_t

◆ mutex_t

◆ renameMap_t

◆ ti_map_t

Constructor & Destructor Documentation

◆ AuxTypeRegistry() [1/2]

◆ ~AuxTypeRegistry()

◆ AuxTypeRegistry() [2/2]

Member Function Documentation

◆ addFactory() [1/4]

◆ addFactory() [2/4]

◆ addFactory() [3/4]

◆ addFactory() [4/4]

◆ checkAuxID() [1/2]

◆ checkAuxID() [2/2]

◆ checkName()

◆ clear()

◆ copy() [1/2]

◆ copy() [2/2]

◆ copyForOutput()

◆ findAuxID() [1/2]

◆ findAuxID() [2/2]

◆ getAllocType()

◆ getAuxID() [1/4]

◆ getAuxID() [2/4]

◆ getAuxID() [3/4]

◆ getAuxID() [4/4]

◆ getClassName()

◆ getEltSize()

◆ getFactory() [1/4]

◆ getFactory() [2/4]

◆ getFactory() [3/4]

◆ getFactory() [4/4]

◆ getFlags()

◆ getName()

◆ getType()

◆ getTypeName()

◆ getVecType()

◆ getVecTypeName()

◆ inputRename()

◆ instance()

◆ makeFactory()

◆ makeFactoryNull()

◆ makeKey()

◆ makeVector()

◆ makeVectorFromData()

◆ numVariables()

◆ operator=()

◆ setInputRenameMap()

◆ swap()

Member Data Documentation

◆ m_allocMap

◆ m_auxids

◆ m_factories

◆ m_mutex

◆ m_oldFactories

◆ m_renameMap

◆ m_types