AuxTypeRegistry.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/exceptions.h"
#include "AthContainers/normalizedTypeinfoName.h"
#include "AthContainers/tools/error.h"
#include "CxxUtils/checker_macros.h"
#include <cassert>
#include <sstream>
#include <cstring>
 
 
namespace SG {
 
 
bool AuxTypeRegistry::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 AuxTypeRegistry auxTypeRegistry ATLAS_THREAD_SAFE;
  return auxTypeRegistry;
}
 
 
size_t AuxTypeRegistry::numVariables() const
{
  return 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*/)
{
  return findAuxID (name, clsname, flags, 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*/)
{
  return findAuxID (name, clsname, flags, ti, &ti_alloc, nullptr,
                    &AuxTypeRegistry::makeFactoryNull);
}
 
 
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*/)
{
  return findAuxID (name, clsname, flags, ti, nullptr, &alloc_type,
                    &AuxTypeRegistry::makeFactoryNull);
}
 
 
SG::auxid_t
AuxTypeRegistry::findAuxID( const std::string& name,
                            const std::string& clsname ) const
{
  // 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;
}
 
 
void AuxTypeRegistry::checkAuxID (const SG::auxid_t auxid,
                                  const std::type_info& ti,
                                  const std::type_info& ti_alloc,
                                  const Flags flags)
{
  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);
  }
}
 
 
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);
}
 
 
std::unique_ptr<IAuxTypeVector>
AuxTypeRegistry::makeVectorFromData (SG::auxid_t auxid,
                                     void* data,
                                     bool isPacked,
                                     bool ownMode) const
{
  const SG::IAuxTypeVectorFactory* factory = getFactory (auxid);
  assert (factory != 0);
  return factory->createFromData (auxid, data, isPacked, ownMode);
}
 
 
std::string AuxTypeRegistry::makeKey (const std::string& name,
                                      const std::string& clsname)
{
  if (clsname.empty()) {
    return name;
  }
  return clsname + "::" + name;
}
 
 
 
std::string AuxTypeRegistry::getName (SG::auxid_t auxid) const
{
  if (auxid >= m_types.size())
    return "";
  return m_types[auxid].m_name;
}
 
 
std::string AuxTypeRegistry::getClassName (SG::auxid_t auxid) const
{
  if (auxid >= m_types.size())
    return "";
  return m_types[auxid].m_clsname;
}
 
 
const std::type_info* AuxTypeRegistry::getType (SG::auxid_t auxid) const
{
  if (auxid >= m_types.size())
    return 0;
  return m_types[auxid].m_ti;
}
 
 
std::string AuxTypeRegistry::getTypeName (SG::auxid_t auxid) const
{
  if (auxid >= m_types.size())
    return "";
  return normalizedTypeinfoName (*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
{
  if (auxid >= m_types.size())
    return 0;
  return 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;
}
 
 
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)
{
  lock_t lock (m_mutex);
  return getFactory (lock, ti, ti_alloc);
}
 
 
const IAuxTypeVectorFactory*
AuxTypeRegistry::getFactory (lock_t& lock,
                             const std::type_info& ti,
                             const std::type_info& ti_alloc)
{
  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;
}
 
 
const IAuxTypeVectorFactory*
AuxTypeRegistry::getFactory (const std::type_info& ti,
                             const std::string& alloc_name)
{
  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;
}
 
 
const IAuxTypeVectorFactory*
AuxTypeRegistry::addFactory (const std::type_info& ti,
                             const std::type_info& ti_alloc,
                             std::unique_ptr<const IAuxTypeVectorFactory> factory)
{
  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);
}
 
 
const IAuxTypeVectorFactory*
AuxTypeRegistry::addFactory (const std::type_info& ti,
                             const std::string& ti_alloc_name,
                             std::unique_ptr<const IAuxTypeVectorFactory> factory)
{
  lock_t lock (m_mutex);
  return addFactory (lock, ti, ti_alloc_name, std::move (factory));
}
 
 
const IAuxTypeVectorFactory*
AuxTypeRegistry::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*
AuxTypeRegistry::addFactory (lock_t& /*lock*/,
                             const std::type_info& ti,
                             const std::string& ti_alloc_name,
                             std::unique_ptr<const IAuxTypeVectorFactory> factory)
{
  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;
}
 
 
AuxTypeRegistry::AuxTypeRegistry()
  : 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::~AuxTypeRegistry()
{
  // 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
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::*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)) &&
          (&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;
}
 
 
#ifndef XAOD_STANDALONE
 
void
AuxTypeRegistry::setInputRenameMap (const Athena::IInputRename::InputRenameMap_t* map,
                                    const IStringPool& pool)
{
  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);
  }
}
#endif
 
 
const std::string& AuxTypeRegistry::inputRename (const std::string& key,
                                                 const std::string& name) const
{
  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;
}
 
 
bool AuxTypeRegistry::checkName (const std::string& s)
{
  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;
}
 
 
} // namespace SG