AuxTypeRegistry.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/exceptions.h"
#include "AthContainers/normalizedTypeinfoName.h"
#include "AthContainers/tools/AuxTypeVector.h"
#include "AthContainers/JaggedVec.h"
#include "AthContainers/tools/error.h"
#include "AthContainers/tools/threading.h"
#include "AthContainers/tools/concurrent_vector.h"
#include "CxxUtils/ConcurrentStrMap.h"
#include "CxxUtils/SimpleUpdater.h"
#include "CxxUtils/checker_macros.h"
#include <cassert>
#include <sstream>
#include <cstring>
#include <algorithm>
 
 
namespace SG {
 

class AuxTypeRegistryImpl
  : public AuxTypeRegistry
{
public:
  AuxTypeRegistryImpl();
 

  ~AuxTypeRegistryImpl();
 
 
  using AuxTypeRegistry::addFactory;
  using AuxTypeRegistry::getFactory;
 

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

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

  const IAuxTypeVectorFactory*
  addFactory (lock_t& /*lock*/,
              const std::type_info& ti,
              const std::string& ti_alloc_name,
              std::unique_ptr<const IAuxTypeVectorFactory> factory);
 

  static bool checkName (std::string_view s) noexcept;
 

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

  struct typeinfo_t
  {
    AthContainers_detail::atomic<const IAuxTypeVectorFactory*> m_factory;

    const std::type_info* m_ti;

    const std::type_info* m_ti_alloc;

    std::string m_alloc_name;

    std::string m_name;

    std::string m_clsname;

    auxid_t m_linked;

    Flags m_flags;

    bool checkAlloc (const std::type_info* ti_alloc,
                     const std::string* alloc_name) const;
  };
 

  // A concurrent vector, so we don't need to take a lock to read it.
  AthContainers_detail::concurrent_vector<typeinfo_t> m_types;

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

  using ti_map_t = CxxUtils::ConcurrentStrMap<const IAuxTypeVectorFactory*, CxxUtils::SimpleUpdater>;
  ti_map_t m_factories;

  std::vector<const IAuxTypeVectorFactory*> m_oldFactories;

  typedef std::unordered_map<std::string, std::string> renameMap_t;
  renameMap_t m_renameMap;
 
  // Map from the TI name for T to the TI for AuxAllocator_t<T>.
  // Filled in by addFactory().  Used in findAuxID() if the allocator
  // type is not specified.
  using allocMap_t = CxxUtils::ConcurrentStrMap<const std::type_info*, CxxUtils::SimpleUpdater>;
  allocMap_t m_allocMap;

  // We originally used an upgrading mutex here.
  // But that's relatively slow, and most of the locked sections are short,
  // so it's not really a win.
  // This guards write access to all members, and read access to all members
  // except for m_types.
  mutable mutex_t m_mutex;
};
 

AuxTypeRegistryImpl::AuxTypeRegistryImpl()
  : 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::~AuxTypeRegistryImpl()
{
  // 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;
}
 

SG::auxid_t
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)
{
  // 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;
}
 

 * an element type of @c 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.
 */
const IAuxTypeVectorFactory*
AuxTypeRegistryImpl::addFactory (lock_t& /*lock*/,
                                 const std::type_info& ti,
                                 const std::type_info& ti_alloc,
                                 const IAuxTypeVectorFactory* factory)
{
  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;
}
 

const IAuxTypeVectorFactory*
AuxTypeRegistryImpl::addFactory (lock_t& /*lock*/,
                                 const std::type_info& ti,
                                 const std::string& ti_alloc_name,
                                 std::unique_ptr<const IAuxTypeVectorFactory> factory)
{
  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;
}
 

bool AuxTypeRegistryImpl::checkName (std::string_view s) noexcept
{
    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 == '_';
     });
}
 

const IAuxTypeVectorFactory*
AuxTypeRegistryImpl::getFactory (lock_t& lock,
                                 const std::type_info& ti,
                                 const std::type_info& ti_alloc)
{
  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;
}
 

bool AuxTypeRegistryImpl::typeinfo_t::checkAlloc (const std::type_info* ti_alloc,
                                                  const std::string* alloc_name) const
{
  if (ti_alloc && m_ti_alloc) {
    if (ti_alloc == m_ti_alloc) return true;
    return strcmp (ti_alloc->name(), m_ti_alloc->name()) == 0;
  }
  if (alloc_name) {
    return *alloc_name == m_alloc_name;
  }
  if (ti_alloc) {
    return SG::normalizedTypeinfoName (*ti_alloc) == m_alloc_name;
  }
  return true;
}
 
 
//***************************************************************************
 

AuxTypeRegistry& AuxTypeRegistry::instance()
{
  static AuxTypeRegistryImpl auxTypeRegistry ATLAS_THREAD_SAFE;
  return auxTypeRegistry;
}
 

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

SG::auxid_t 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*/)
{
  auto impl = static_cast<AuxTypeRegistryImpl*> (this);
  return impl->findAuxID (name, clsname, flags, linkedVariable,
                          ti, nullptr, nullptr,
                          &AuxTypeRegistry::makeFactoryNull);
}
 

SG::auxid_t 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*/)
{
  auto impl = static_cast<AuxTypeRegistryImpl*> (this);
  return impl->findAuxID (name, clsname, flags, linkedVariable,
                          ti, &ti_alloc, nullptr,
                          makeFactory);
}
 

SG::auxid_t 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*/)
{
  auto impl = static_cast<AuxTypeRegistryImpl*> (this);
  return impl->findAuxID (name, clsname, flags, linkedVariable,
                          ti, nullptr, &alloc_type,
                          &AuxTypeRegistry::makeFactoryNull);
}
 

SG::auxid_t
AuxTypeRegistry::findAuxID (const std::string& name,
                            const std::string& clsname) const
{
  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;
}
 

void AuxTypeRegistry::checkAuxID (const SG::auxid_t auxid,
                                  const std::type_info& ti,
                                  const std::type_info& ti_alloc,
                                  const Flags flags)
{
  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);
  }
}
 

std::unique_ptr<IAuxTypeVector>
AuxTypeRegistry::makeVector (SG::auxid_t auxid,
                             size_t size,
                             size_t capacity) const
{
  const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
  assert (factory != 0);
  return factory->create (auxid, size, capacity, isLinked (auxid));
}
 

std::unique_ptr<IAuxTypeVector>
AuxTypeRegistry::makeVectorFromData (SG::auxid_t auxid,
                                     void* data,
                                     IAuxTypeVector* linkedVector,
                                     bool isPacked,
                                     bool ownMode) const
{
  const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
  assert (factory != 0);
  return factory->createFromData (auxid, data, linkedVector,
                                  isPacked, ownMode, isLinked (auxid));
}
 

std::string AuxTypeRegistry::makeKey (const std::string& name,
                                      const std::string& clsname)
{
  if (clsname.empty()) {
    return name;
  }
  std::string output = clsname;
  output += "::";
  output += name;
  return output;
}
 
 

std::string AuxTypeRegistry::getName (SG::auxid_t auxid) const
{
  auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
  if (auxid >= impl->m_types.size())
    return "";
  return impl->m_types[auxid].m_name;
}
 

std::string AuxTypeRegistry::getClassName (SG::auxid_t auxid) const
{
  auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
  if (auxid >= impl->m_types.size())
    return "";
  return impl->m_types[auxid].m_clsname;
}
 

const std::type_info* AuxTypeRegistry::getType (SG::auxid_t auxid) const
{
  auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
  if (auxid >= impl->m_types.size())
    return 0;
  return impl->m_types[auxid].m_ti;
}
 

std::string AuxTypeRegistry::getTypeName (SG::auxid_t auxid) const
{
  auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
  if (auxid >= impl->m_types.size())
    return "";
  return normalizedTypeinfoName (*impl->m_types[auxid].m_ti);
}
 

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

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

const std::type_info* AuxTypeRegistry::getAllocType (SG::auxid_t auxid) const
{
  auto impl = static_cast<const AuxTypeRegistryImpl*> (this);
  if (auxid >= impl->m_types.size())
    return 0;
  return impl->m_types[auxid].m_ti_alloc;
}
 

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

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

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

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

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

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

void AuxTypeRegistry::clear (SG::auxid_t auxid,
                             AuxVectorData& dst, size_t dst_index,
                             size_t n) const
{
  const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
  if (factory)
    factory->clear (auxid, dst, dst_index, n);
}
 

const IAuxTypeVectorFactory*
AuxTypeRegistry::getFactory (const std::type_info& ti,
                             const std::type_info& ti_alloc)
{
  auto impl = static_cast<AuxTypeRegistryImpl*> (this);
  lock_t lock (impl->m_mutex);
  return impl->getFactory (lock, ti, ti_alloc);
}
 

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

const IAuxTypeVectorFactory*
AuxTypeRegistry::getFactory (const std::type_info& ti,
                             const std::string& alloc_name)
{
  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;
}
 

const IAuxTypeVectorFactory*
AuxTypeRegistry::addFactory (const std::type_info& ti,
                             const std::type_info& ti_alloc,
                             std::unique_ptr<const IAuxTypeVectorFactory> factory)
{
  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);
}
 

const IAuxTypeVectorFactory*
AuxTypeRegistry::addFactory (const std::type_info& ti,
                             const std::string& ti_alloc_name,
                             std::unique_ptr<const IAuxTypeVectorFactory> factory)
{
  auto impl = static_cast<AuxTypeRegistryImpl*> (this);
  lock_t lock (impl->m_mutex);
  return impl->addFactory (lock, ti, ti_alloc_name, std::move (factory));
}
 

AuxTypeRegistry::AuxTypeRegistry()
{
}
 

AuxTypeRegistry::~AuxTypeRegistry()
{
}
 
 
#ifndef XAOD_STANDALONE
void
AuxTypeRegistry::setInputRenameMap (const Athena::InputRenameMap_t* map,
                                    const IStringPool& pool)
{
  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);
  }
}
#endif
 

const std::string& AuxTypeRegistry::inputRename (const std::string& key,
                                                 const std::string& name) const
{
  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;
}
 

bool AuxTypeRegistry::isLinkedName (const std::string& name)
{
  return name.ends_with ("_linked");
}
 

std::string AuxTypeRegistry::linkedName (const std::string& name)
{
  return name + "_linked";
}
 

bool AuxTypeRegistry::classNameHasLink (const std::string& className)
{
  if (className.find ("SG::JaggedVecElt<") != std::string::npos) {
    return true;
  }
  if (className.find ("SG::PackedLink<") != std::string::npos) {
    return true;
  }
  return false;
}
 
 
} // namespace SG