SG::AuxTypeRegistryImpl Class Reference

@Brief Implementation class for AuxTypeRegistry. More...

Inheritance diagram for SG::AuxTypeRegistryImpl:

Collaboration diagram for SG::AuxTypeRegistryImpl:

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

Public Types
using	id_map_t = CxxUtils::ConcurrentStrMap<SG::auxid_t, CxxUtils::SimpleUpdater>
	Map from name -> auxid.
using	ti_map_t = CxxUtils::ConcurrentStrMap<const IAuxTypeVectorFactory*, CxxUtils::SimpleUpdater>
	Map from type_info name + allocator ti name -> IAuxTypeVectorFactory.
typedef std::unordered_map< std::string, std::string >	renameMap_t
	Save the information provided by setInputRenameMap.
using	allocMap_t = CxxUtils::ConcurrentStrMap<const std::type_info*, CxxUtils::SimpleUpdater>
using	Flags = SG::AuxVarFlags
	Additional flags to qualify an auxiliary variable.

Public Member Functions
	AuxTypeRegistryImpl ()
	Constructor.
	~AuxTypeRegistryImpl ()
	Destructor.
SG::auxid_t	findAuxID (const std::string &name, const std::string &clsname, const Flags flags, const SG::auxid_t linkedVariable, 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.
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.
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.
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.
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.
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.
const IAuxTypeVectorFactory *	getFactory (const std::type_info &ti, const std::type_info &ti_alloc)
	Return the vector factory for a given vector element type.
const IAuxTypeVectorFactory *	getFactory (const std::type_info &ti, const std::string &alloc_name)
	Return the vector factory for a given vector element type.
const IAuxTypeVectorFactory *	getFactory (SG::auxid_t auxid) const
	Return the vector factory for a given auxid.
size_t	numVariables () const
	Return the total number of registered auxiliary variable.
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.
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.
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.
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.
SG::auxid_t	findAuxID (const std::string &name, const std::string &clsname="") const
	Look up a name -> auxid_t mapping.
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.
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.
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.
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.
std::string	getName (SG::auxid_t auxid) const
	Return the name of an aux data item.
std::string	getClassName (SG::auxid_t auxid) const
	Return the class name associated with an aux data item (may be blank).
const std::type_info *	getType (SG::auxid_t auxid) const
	Return the type of an aux data item.
std::string	getTypeName (SG::auxid_t auxid) const
	Return the type name of an aux data item.
const std::type_info *	getVecType (SG::auxid_t auxid) const
	Return the type of the STL vector used to hold an aux data item.
std::string	getVecTypeName (SG::auxid_t auxid) const
	Return the type of the STL vector used to hold an aux data item.
const std::type_info *	getAllocType (SG::auxid_t auxid) const
	Return the type of the vector allocator.
size_t	getEltSize (SG::auxid_t auxid) const
	Return size of an element in the STL vector.
Flags	getFlags (SG::auxid_t auxid) const
	Return flags associated with an auxiliary variable.
bool	isLinked (SG::auxid_t auxid) const
	Test whether this is a linked variable.
SG::auxid_t	linkedVariable (SG::auxid_t auxid) const
	Return the auxid if the linked variable, if there is one.
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.
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.
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.
void	swap (SG::auxid_t auxid, AuxVectorData &a, size_t aindex, AuxVectorData &b, size_t bindex, size_t n) const
	Swap elements between vectors.
void	clear (SG::auxid_t auxid, AuxVectorData &dst, size_t dst_index, size_t n) const
	Clear a range of elements within a vector.
void	setInputRenameMap (const Athena::InputRenameMap_t *map, const IStringPool &pool)
	Declare input renaming requests.
const std::string &	inputRename (const std::string &key, const std::string &name) const
	Check for an input renaming of an auxiliary variable.

Static Public Member Functions
static bool	checkName (std::string_view s) noexcept
	Check for valid variable name.
static AuxTypeRegistry &	instance ()
	Return the singleton registry instance.
static bool	isLinkedName (const std::string &name)
	Test if a variable name corresponds to a linked variable.
static std::string	linkedName (const std::string &name)
	Given a variable name, return the name of the corresponding linked variable.
static bool	classNameHasLink (const std::string &className)
	Test to see if a class name corresponds to a class with a linked variable.

Public Attributes
AthContainers_detail::concurrent_vector< typeinfo_t >	m_types
	Table of aux data items, indexed by auxid.
id_map_t	m_auxids
ti_map_t	m_factories
std::vector< const IAuxTypeVectorFactory * >	m_oldFactories
	Hold additional factory instances we need to delete.
renameMap_t	m_renameMap
allocMap_t	m_allocMap
mutex_t	m_mutex
	Mutex controlling access to the registry.

Private Types
typedef AthContainers_detail::mutex	mutex_t
typedef AthContainers_detail::lock_guard< mutex_t >	lock_t

Private Member Functions
template<class T, class ALLOC = AuxAllocator_t<T>>
std::unique_ptr< IAuxTypeVectorFactory >	makeFactory () const
	Create an AuxTypeVectorFactory instance.
std::unique_ptr< IAuxTypeVectorFactory >	makeFactoryNull () const
	makeFactory implementation that always returns nullptr.

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.

Detailed Description

@Brief Implementation class for AuxTypeRegistry.

We split this off in order to reduce compile-time dependencies on tbb and ConcurrentStrMap. Since this can get accessed frequently, but is a singleton, we don't use the more commom pimpl idiom. Instead, we put the implementation stuff in a derived class. The function that creates the singleton actually makes an instance of the derived class, and we static_cast to the derived class where needed. Since instances of this cannot be created anywhere else, this is safe.

Definition at line 44 of file AuxTypeRegistry.cxx.

Member Typedef Documentation

allocMap_t

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

Definition at line 223 of file AuxTypeRegistry.cxx.

Flags

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

inherited

Additional flags to qualify an auxiliary variable.

Definition at line 65 of file AuxTypeRegistry.h.

id_map_t

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

Map from name -> auxid.

Definition at line 205 of file AuxTypeRegistry.cxx.

lock_t

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

privateinherited

Definition at line 541 of file AuxTypeRegistry.h.

mutex_t

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

privateinherited

Definition at line 540 of file AuxTypeRegistry.h.

renameMap_t

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

Save the information provided by setInputRenameMap.

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

Definition at line 217 of file AuxTypeRegistry.cxx.

ti_map_t

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

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

Definition at line 209 of file AuxTypeRegistry.cxx.

Constructor & Destructor Documentation

AuxTypeRegistryImpl()

SG::AuxTypeRegistryImpl::AuxTypeRegistryImpl

(

)

Constructor.

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

Definition at line 241 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) AuxTypeRegistry::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>);
 
  ADD_FACTORY (SG::JaggedVecElt<char>);
  ADD_FACTORY (SG::JaggedVecElt<unsigned char>);
  ADD_FACTORY (SG::JaggedVecElt<short>);
  ADD_FACTORY (SG::JaggedVecElt<unsigned short>);
  ADD_FACTORY (SG::JaggedVecElt<int>);
  ADD_FACTORY (SG::JaggedVecElt<unsigned int>);
  ADD_FACTORY (SG::JaggedVecElt<long>);
  ADD_FACTORY (SG::JaggedVecElt<unsigned long>);
  ADD_FACTORY (SG::JaggedVecElt<long long>);
  ADD_FACTORY (SG::JaggedVecElt<unsigned long long>);
  ADD_FACTORY (SG::JaggedVecElt<float>);
  ADD_FACTORY (SG::JaggedVecElt<double>);
  ADD_FACTORY (SG::JaggedVecElt<std::string>);
#undef ADD_FACTORY
}

~AuxTypeRegistryImpl()

SG::AuxTypeRegistryImpl::~AuxTypeRegistryImpl

(

)

Destructor.

Delete factory instances.

Definition at line 294 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;
}

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 484 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/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 467 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);
}

addFactory() [3/4]

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

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

{
  std::string key = ti.name();
  key += ';';
  key += 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);
      fac = m_factories.insert_or_assign (key, factory.release()).first->second;
    }
    else {
      fac = it->second;
    }
  }
  else
    fac = m_factories.insert_or_assign (key, factory.release()).first->second;
 
  return fac;
}

addFactory() [4/4]

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

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

inherited

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 )

inherited

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

checkName()

bool SG::AuxTypeRegistryImpl::checkName ( std::string_view s )

staticnoexcept

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

{
    if (s.empty()) return false;
    char first = s[0];
    if (!std::isalpha(static_cast<unsigned char>(first)) && first != '_') return false;
    return std::all_of(s.begin() + 1, s.end(), [](char c) {
         return std::isalnum(static_cast<unsigned char>(c)) || c == '_';
     });
}

classNameHasLink()

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

staticinherited

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

Definition at line 1313 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

inherited

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

inherited

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

inherited

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

inherited

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

inherited

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

findAuxID() [2/2]

SG::auxid_t SG::AuxTypeRegistryImpl::findAuxID	(	const std::string &	name,
		const std::string &	clsname,
		const Flags	flags,
		const SG::auxid_t	linkedVariable,
		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.

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.
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 332 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)) &&
          (CxxUtils::test (m.m_flags, Flags::Linked) == CxxUtils::test (flags, Flags::Linked)) &&
          (linkedVariable == m.m_linked) &&
          (&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)) ||
        (CxxUtils::test (m.m_flags, Flags::Linked) != CxxUtils::test (flags, Flags::Linked)))
    {
      throw SG::ExcFlagMismatch (i->second, ti, m.m_flags, flags);
    }
 
    if (linkedVariable != m.m_linked)
    {
      throw SG::ExcLinkMismatch (i->second, ti, m.m_linked, linkedVariable);
    }
 
    // 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);
  t.m_linked = linkedVariable;
  if (linkedVariable != SG::null_auxid) {
    if (!isLinked (linkedVariable)) std::abort();
  }
  AthContainers_detail::fence_seq_cst();
  m_auxids.insert_or_assign (key, auxid);
 
  return auxid;
}

getAllocType()

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

inherited

Return the type of the vector allocator.

Parameters

auxid

The desired aux data item.

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

inherited

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

inherited

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 )

inherited

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 673 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::* makeFactory )() const = &AuxTypeRegistry::makeFactoryNull )

inherited

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

inherited

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

Parameters

auxid

The desired aux data item.

Definition at line 896 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

inherited

Return size of an element in the STL vector.

Parameters

auxid

The desired aux data item.

Definition at line 978 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 441 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/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 429 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/4]

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

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

{
  std::string key = ti.name();
  key += ";TI;";
  key += 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.)

Definition at line 452 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

inherited

Return flags associated with an auxiliary variable.

Parameters

auxid

The desired aux data item.

Definition at line 991 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

inherited

Return the name of an aux data item.

Parameters

auxid

The desired aux data item.

Definition at line 882 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

inherited

Return the type of an aux data item.

Parameters

auxid

The desired aux data item.

Definition at line 909 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

inherited

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

inherited

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

Parameters

auxid

The desired aux data item.

Definition at line 937 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

inherited

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

inherited

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

staticinherited

Return the singleton registry instance.

Definition at line 640 of file AuxTypeRegistry.cxx.

{
  static AuxTypeRegistryImpl auxTypeRegistry ATLAS_THREAD_SAFE;
  return auxTypeRegistry;
}

isLinked()

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

inherited

Test whether this is a linked variable.

Parameters

auxid

The aux data item to test.

isLinkedName()

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

staticinherited

Test if a variable name corresponds to a linked variable.

Definition at line 1293 of file AuxTypeRegistry.cxx.

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

linkedName()

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

staticinherited

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

Definition at line 1303 of file AuxTypeRegistry.cxx.

{
  return name + "_linked";
}

linkedVariable()

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

inherited

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

privateinherited

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

privateinherited

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 )

staticprivateinherited

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

inherited

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

inherited

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

inherited

Return the total number of registered auxiliary variable.

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

Definition at line 652 of file AuxTypeRegistry.cxx.

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

setInputRenameMap()

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

inherited

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

inherited

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 1074 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::AuxTypeRegistryImpl::m_allocMap

Definition at line 224 of file AuxTypeRegistry.cxx.

m_auxids

id_map_t SG::AuxTypeRegistryImpl::m_auxids

Definition at line 206 of file AuxTypeRegistry.cxx.

m_factories

ti_map_t SG::AuxTypeRegistryImpl::m_factories

Definition at line 210 of file AuxTypeRegistry.cxx.

m_mutex

mutex_t SG::AuxTypeRegistryImpl::m_mutex

mutable

Mutex controlling access to the registry.

Definition at line 232 of file AuxTypeRegistry.cxx.

m_oldFactories

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

Hold additional factory instances we need to delete.

Definition at line 213 of file AuxTypeRegistry.cxx.

m_renameMap

renameMap_t SG::AuxTypeRegistryImpl::m_renameMap

Definition at line 218 of file AuxTypeRegistry.cxx.

m_types

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

Table of aux data items, indexed by auxid.

Definition at line 202 of file AuxTypeRegistry.cxx.

---

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

• AuxTypeRegistry.cxx