BaseInfo.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

 
#include "AthenaKernel/BaseInfo.h"
#include "AthenaKernel/CLIDRegistry.h"
#include "CxxUtils/CachedValue.h"
#include "GaudiKernel/System.h"
#include <mutex>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <iostream>
#include "string.h"
 
 
namespace SG {
 
 
struct BaseInfoBaseImpl {
  struct info {
    info (BaseInfoBase::castfn_t* converter = 0,
          BaseInfoBase::castfn_t* converterTo = 0,
          bool is_virtual = false);

    BaseInfoBase::castfn_t* m_converter;

    BaseInfoBase::castfn_t* m_converterTo;

    bool m_is_virtual;
  };
 

  CLID m_clid;

  bool m_needs_init;

  const std::type_info* m_typeinfo;
 

  typedef std::pair<const std::type_info*, info> ti_map_pair_type;
  typedef std::vector<ti_map_pair_type> ti_map_type;
  ti_map_type m_timap;
 

  typedef std::pair<const std::type_info*, const CopyConversionBase*>
  ti_copyconversion_pair_type;
  typedef std::vector<ti_copyconversion_pair_type> ti_copyconversion_type;
  ti_copyconversion_type m_ti_copyconversion_map;
 

  typedef std::unordered_map<const std::type_info*, BaseInfoBase*> bi_by_ti_map_type;
  static bi_by_ti_map_type* s_bi_by_ti ATLAS_THREAD_SAFE;
 

  typedef std::unordered_map<std::string, const std::type_info*> ti_by_name_map_type;
  static ti_by_name_map_type* s_ti_by_name ATLAS_THREAD_SAFE;
 

  typedef std::unordered_multimap<const std::type_info*,
                                  BaseInfoBase::init_func_t*> init_list_t;
  static init_list_t* s_init_list ATLAS_THREAD_SAFE;
 
 
  // To make sure that the maps get deleted at program termination.
  struct Deleter {
    ~Deleter();
  };
  static Deleter s_deleter;

  typedef std::mutex mutex_t;
  typedef std::lock_guard<mutex_t> lock_t;
  static mutex_t s_mutex ATLAS_THREAD_SAFE;   // For the static variables.
  mutable mutex_t m_mutex;  // For the class members.
 

  CxxUtils::CachedValue<std::vector<CLID> > m_bases;
 
  
  const info* findInfo (const std::type_info& tinfo) const
  {
    // We don't expect there to be many entries, so just use a linear search.
    for (const auto& i : m_timap) {
      if (i.first == &tinfo)
        return &i.second;
    }
 
    // Sometimes type_info's are not actually unique, depending on how libraries
    // get loaded.  Try again, comparing names.
    for (const auto& i : m_timap) {
      if (strcmp (i.first->name(), tinfo.name()) == 0)
        return &i.second;
    }
    return nullptr;
  }
};
 
 

CLID BaseInfoBase::clid() const
{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  return m_impl->m_clid;
}
 

const std::type_info& BaseInfoBase::typeinfo() const
{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  return *m_impl->m_typeinfo;
}
 

void* BaseInfoBase::cast (void* p, CLID clid) const
{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->cast (p, *ti);
  return 0;
}
 

void* BaseInfoBase::cast (void* p, const std::type_info& tinfo) const
{
  if (BaseInfoBase::castfn_t* converter = castfn (tinfo)) {
    return converter (p);
  }
  return nullptr;
}
 

void* BaseInfoBase::castTo (void* p, CLID clid) const
{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->castTo (p, *ti);
  return 0;
}
 

void* BaseInfoBase::castTo (void* p, const std::type_info& tinfo) const
{
  if (BaseInfoBase::castfn_t* converterTo = castfnTo (tinfo)) {
    return converterTo (p);
  }
  return nullptr;
}
 

BaseInfoBase::castfn_t* BaseInfoBase::castfn (CLID clid) const
{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->castfn (*ti);
  return 0;
}
 

BaseInfoBase::castfn_t*
BaseInfoBase::castfn (const std::type_info& tinfo) const
{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  const BaseInfoBaseImpl::info* i = m_impl->findInfo (tinfo);
  if (i)
    return i->m_converter;
  return nullptr;
}
 

BaseInfoBase::castfn_t* BaseInfoBase::castfnTo (CLID clid) const
{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->castfnTo (*ti);
  return 0;
}
 

BaseInfoBase::castfn_t*
BaseInfoBase::castfnTo (const std::type_info& tinfo) const
{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  const BaseInfoBaseImpl::info* i = m_impl->findInfo (tinfo);
  if (i)
    return i->m_converterTo;
  return nullptr;
}
 

const std::vector<CLID>& BaseInfoBase::get_bases() const
{
  if (!m_impl->m_bases.isValid()) {
    BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
    const BaseInfoBaseImpl::ti_map_type& map = m_impl->m_timap;
    std::vector<CLID> v;
    v.reserve (map.size());
    for (const auto& p : map) {
      CLID clid = CLIDRegistry::typeinfoToCLID (*p.first);
      if (clid != CLID_NULL)
        v.push_back (clid);
    }
    m_impl->m_bases.set (std::move (v));
  }
  return *m_impl->m_bases.ptr();
}
 

std::vector<const std::type_info*> BaseInfoBase::get_ti_bases() const
{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  const BaseInfoBaseImpl::ti_map_type& map = m_impl->m_timap;
  std::vector<const std::type_info*> v;
  v.reserve (map.size());
  for (const auto& i : map)
    v.push_back (i.first);
  return v;
}
 

bool BaseInfoBase::is_base (CLID clid) const
{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->is_base (*ti);
  return 0;
}
 

bool BaseInfoBase::is_base (const std::type_info& tinfo) const
{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  const BaseInfoBaseImpl::info* i = m_impl->findInfo (tinfo);
  return i != 0;
}
 

bool BaseInfoBase::is_virtual (CLID clid) const
{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->is_virtual (*ti);
  return false;
}
 

bool BaseInfoBase::is_virtual (const std::type_info& tinfo) const
{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  const BaseInfoBaseImpl::info* i = m_impl->findInfo (tinfo);
  if (i)
    return i->m_is_virtual;
  return false;
}
 

const CopyConversionBase*
BaseInfoBase::copy_conversion (const std::type_info& tinfo) const
{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  for (const auto& p : m_impl->m_ti_copyconversion_map) {
    if (p.first == &tinfo)
      return p.second;
  }
  return 0;
}
 

const CopyConversionBase*
BaseInfoBase::copy_conversion (CLID clid) const
{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->copy_conversion (*ti);
  return 0;
}
 

void
BaseInfoBase::add_copy_conversion (const std::type_info& tinfo,
                                   const CopyConversionBase* cnv)
{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  m_impl->m_ti_copyconversion_map.emplace_back (&tinfo, cnv);
}
 

std::vector<CLID>
BaseInfoBase::get_copy_conversions() const
{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  std::vector<CLID> out;
  out.reserve (m_impl->m_ti_copyconversion_map.size());
  for (const auto& i : m_impl->m_ti_copyconversion_map) {
    CLID clid = CLIDRegistry::typeinfoToCLID (*i.first);
    if (clid != CLID_NULL)
      out.push_back (clid);
  }
  return out;
}
 

void BaseInfoBase::add_info (const std::type_info& tinfo,
                             castfn_t* converter,
                             castfn_t* converterTo,
                             bool is_virtual)
{
  BaseInfoBaseImpl::lock_t slock (BaseInfoBaseImpl::s_mutex);
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  {
    const BaseInfoBaseImpl::info* i = m_impl->findInfo (tinfo);
    if (!i) {
      m_impl->m_timap.emplace_back (&tinfo,
                                    BaseInfoBaseImpl::info (converter, converterTo, is_virtual));
    }
  }
 
  auto i = BaseInfoBaseImpl::s_bi_by_ti->find (&tinfo);
  if (i != BaseInfoBaseImpl::s_bi_by_ti->end()) {
    BaseInfoBaseImpl& impl = *i->second->m_impl;
    if (impl.m_clid == CLID_NULL)
      impl.m_clid = CLIDRegistry::typeinfoToCLID (tinfo);
  }
}
 

BaseInfoBaseImpl::info::info (BaseInfoBase::castfn_t* converter /*= 0*/,
                              BaseInfoBase::castfn_t* converterTo /*= 0*/,
                              bool is_virtual /*= false*/)
  : m_converter (converter),
    m_converterTo (converterTo),
    m_is_virtual (is_virtual)
{
}
 

BaseInfoBase::BaseInfoBase (const std::type_info& tinfo)
  : m_impl (new BaseInfoBaseImpl)
{
  m_impl->m_clid = CLIDRegistry::typeinfoToCLID (tinfo);
  m_impl->m_typeinfo = &tinfo;
  m_impl->m_needs_init = true;
 
  BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
  if (!BaseInfoBaseImpl::s_bi_by_ti)
    BaseInfoBaseImpl::s_bi_by_ti   = new BaseInfoBaseImpl::bi_by_ti_map_type;
  if (!BaseInfoBaseImpl::s_ti_by_name)
    BaseInfoBaseImpl::s_ti_by_name   = new BaseInfoBaseImpl::ti_by_name_map_type;
 
  // Register this instance in the static maps.
  (*BaseInfoBaseImpl::s_bi_by_ti)[&tinfo] = this;
  (*BaseInfoBaseImpl::s_ti_by_name)[tinfo.name()] = &tinfo;
}
 

BaseInfoBase::~BaseInfoBase()
{
  for (BaseInfoBaseImpl::ti_copyconversion_type::iterator it =
         m_impl->m_ti_copyconversion_map.begin();
       it != m_impl->m_ti_copyconversion_map.end();
       ++it)
  {
    delete it->second;
  }
  delete m_impl;
}
 

const BaseInfoBase* BaseInfoBase::find (CLID clid)
{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return BaseInfoBase::find (*ti);
  return 0;
}
 

BaseInfoBase* BaseInfoBase::find1 (const std::type_info& tinfo)
{
  BaseInfoBase* bib = nullptr;
  {
    BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
    if (!BaseInfoBaseImpl::s_bi_by_ti) return 0;
    BaseInfoBaseImpl::bi_by_ti_map_type::iterator i = 
      BaseInfoBaseImpl::s_bi_by_ti->find (&tinfo);
    if (i != BaseInfoBaseImpl::s_bi_by_ti->end()) {
      bib = i->second;
      BaseInfoBaseImpl::lock_t lock (bib->m_impl->m_mutex);
      if (!bib->m_impl->m_needs_init)
        return bib;
      bib->m_impl->m_needs_init = false;
    }
  }
 
  // Try the initlist.
  while (true) {
    BaseInfoBase::init_func_t* init = nullptr;
    {
      BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
      if (!BaseInfoBaseImpl::s_init_list) break;
      BaseInfoBaseImpl::bi_by_ti_map_type::iterator i = 
        BaseInfoBaseImpl::s_bi_by_ti->find (&tinfo);
      if (i != BaseInfoBaseImpl::s_bi_by_ti->end())
        bib = i->second;
      BaseInfoBaseImpl::init_list_t::iterator it = 
        BaseInfoBaseImpl::s_init_list->find (&tinfo);
      if (it == BaseInfoBaseImpl::s_init_list->end()) break;
      init = it->second;
      BaseInfoBaseImpl::s_init_list->erase (it);
    }
    init (bib);
  }
 
  return bib;
}
 

const BaseInfoBase* BaseInfoBase::find (const std::type_info& tinfo)
{
  BaseInfoBase* bib = find1 (tinfo);
 
  // If we didn't find it, try looking up by name.
  // This to deal with the issue of sometimes getting duplicate
  // @c std::type_info instances.
  if (!bib) {
    const std::type_info* tinfo2 = nullptr;
    {
      BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
      if (BaseInfoBaseImpl::s_ti_by_name) {
        BaseInfoBaseImpl::ti_by_name_map_type::iterator i = 
          BaseInfoBaseImpl::s_ti_by_name->find (tinfo.name());
        if (i != BaseInfoBaseImpl::s_ti_by_name->end() && i->second != &tinfo) {
          tinfo2 = i->second;
        }
      }
    }
    if (tinfo2) {
      bib = find1 (*tinfo2);
    }
  }
 
  if (bib) {
    BaseInfoBaseImpl& impl = *bib->m_impl;
    BaseInfoBaseImpl::lock_t lock (impl.m_mutex);
    if (impl.m_clid == CLID_NULL)
      impl.m_clid = CLIDRegistry::typeinfoToCLID (*impl.m_typeinfo);
  }
 
  return bib;
}
 

void BaseInfoBase::addInit (const std::type_info* tinfo,
                            init_func_t* init_func)
{
  BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
  if (!BaseInfoBaseImpl::s_init_list)
    BaseInfoBaseImpl::s_init_list =
      new BaseInfoBaseImpl::init_list_t;
  BaseInfoBaseImpl::s_init_list->insert (std::make_pair (tinfo, init_func));
 
  if (BaseInfoBaseImpl::s_bi_by_ti) {
    auto i = BaseInfoBaseImpl::s_bi_by_ti->find (tinfo);
    if (i != BaseInfoBaseImpl::s_bi_by_ti->end()) {
      BaseInfoBaseImpl::lock_t lock (i->second->m_impl->m_mutex);
      BaseInfoBaseImpl& impl = *i->second->m_impl;
      impl.m_needs_init = true;
      if (impl.m_clid == CLID_NULL)
        impl.m_clid = CLIDRegistry::typeinfoToCLID (*tinfo);
    }
  }
}
 

void BaseInfoBase::maybeInit()
{
  // This may be null during initialization, if we're initializing a
  // BaseInfo<T>::s_instance instance which references another type
  // for which the s_instance constructor has not yet been run.
  if (!m_impl) return;
 
  bool needs_init = false;
  const std::type_info* ti = nullptr;
  {
    BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
    needs_init = m_impl->m_needs_init;
    ti = m_impl->m_typeinfo;
  }
  
  if (needs_init)
    find (*ti);
}
 
 

BaseInfoBaseImpl::bi_by_ti_map_type*        BaseInfoBaseImpl::s_bi_by_ti = 0;
BaseInfoBaseImpl::ti_by_name_map_type*        BaseInfoBaseImpl::s_ti_by_name = 0;
BaseInfoBaseImpl::init_list_t*               BaseInfoBaseImpl::s_init_list = 0;
BaseInfoBaseImpl::mutex_t                    BaseInfoBaseImpl::s_mutex;
 
// To get them deleted.
BaseInfoBaseImpl::Deleter BaseInfoBaseImpl::s_deleter;
BaseInfoBaseImpl::Deleter::~Deleter()
{
  delete s_bi_by_ti;
  delete s_ti_by_name;
  delete s_init_list;
}
 
 
// Helper for dumping within the debugger.
void dumpBaseInfo()
{
  BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
  std::cout << "map:\n";
  if (BaseInfoBaseImpl::s_bi_by_ti) {
    std::vector<const std::type_info*> vv;
    for (const auto& x : *BaseInfoBaseImpl::s_bi_by_ti)
      vv.push_back (x.first);
    std::sort (vv.begin(), vv.end());
    for (const std::type_info* ti : vv)
    {
      const BaseInfoBase* bib = (*BaseInfoBaseImpl::s_bi_by_ti)[ti];
      std::cout << ti << " " << bib->clid() << " [" << System::typeinfoName (*ti)
                << "]\n";
    }
  }
 
  std::cout << "\ninitlist:\n";
  if (BaseInfoBaseImpl::s_init_list) {
    for (const auto& x : *BaseInfoBaseImpl::s_init_list)
      std::cout << x.first << " " << x.second << " ["
                << System::typeinfoName (*x.first) << "]\n";
  }
}
 
 
} // namespace SG