ClassIDSvc.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include <cstdlib>
#include <format>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string_view>
#include <CxxUtils/StringUtils.h>
 
#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/ModuleIncident.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ServiceHandle.h"
#include "AthenaKernel/CLIDRegistry.h"
#include "AthenaKernel/errorcheck.h"
#include "CxxUtils/checker_macros.h"
 
#include "ClassIDSvc.h"
 
namespace {
  bool tryNumeric (const std::string& s, CLID& clid)
  {
    clid = CLID_NULL;
    char* endptr = nullptr;
    clid = strtol (s.c_str(), &endptr, 10);
    return clid != CLID_NULL && endptr == (s.c_str() + s.size());
  }
  
 
// HACK LIFTED FROM AthenaBaseComps/AthMsgStreamMacros.h to remove dep loop
#define ATH_MSG_OPEN (
#define ATH_MSG_CLOSE )
#define ATH_MSG_LVL(lvl, x, ...)             \
   do {                                      \
     if (msgLevel(lvl)) {                    \
       msgStream(lvl) << __VA_OPT__(std::format ATH_MSG_OPEN ) x  __VA_OPT__ (, __VA_ARGS__ ATH_MSG_CLOSE) << endmsg; \
     }                                       \
   } while (0)
 
#define ATH_MSG_VERBOSE(x, ...) ATH_MSG_LVL(MSG::VERBOSE, x __VA_OPT__(, __VA_ARGS__))
#define ATH_MSG_DEBUG(x, ...)   ATH_MSG_LVL(MSG::DEBUG, x __VA_OPT__(, __VA_ARGS__))
#define ATH_MSG_INFO(x, ...)    ATH_MSG_LVL(MSG::INFO, x __VA_OPT__(, __VA_ARGS__))
#define ATH_MSG_WARNING(x, ...) ATH_MSG_LVL(MSG::WARNING, x __VA_OPT__(, __VA_ARGS__))
#define ATH_MSG_ERROR(x, ...)   ATH_MSG_LVL(MSG::ERROR, x __VA_OPT__(, __VA_ARGS__))
 
#define ATH_CONST_MSG_VERBOSE(x, ...)             \
  do {                                            \
    if (msgLevel(MSG::VERBOSE)) {                 \
      verbose() << __VA_OPT__(std::format ATH_MSG_OPEN ) x  __VA_OPT__ (, __VA_ARGS__ ATH_MSG_CLOSE) << endmsg; \
    }                                             \
  } while (0)
 
}
 

CLID 
ClassIDSvc::nextAvailableID() const {
  lock_t lock (m_mutex);
  maybeRescan();
  CLID valid(CLIDdetail::MINCLID);
  while (valid <= CLIDdetail::MAXCLID &&
         m_clidMap.find(valid) != m_clidMap.end())
  {
    ++valid;
  }
 
  if (valid > CLIDdetail::MAXCLID) {
    throw std::runtime_error("ClassIDSvc::nextAvailableID: none in range");
  }
 
  return valid;
}
 
 
bool
ClassIDSvc::isIDInUse(const CLID& id ) const {
  lock_t lock (m_mutex);
  maybeRescan();
  return m_clidMap.find(id) != m_clidMap.end();
}
 
 
bool
ClassIDSvc::isNameInUse(const std::string& name ) const {
  lock_t lock (m_mutex);
  maybeRescan();
  return m_nameMap.find(name) != m_nameMap.end();
}
 

StatusCode 
ClassIDSvc::getTypeNameOfID(const CLID& id, std::string& typeName) const
{
  lock_t lock (m_mutex);
  maybeRescan();
 
  CLIDMap::const_iterator iID = m_clidMap.find(id);
  if (iID != m_clidMap.end()) {
    typeName = iID->second.first;
    ATH_CONST_MSG_VERBOSE( "getTypeNameOfID({}) type name is {}", id, typeName );
    return StatusCode::SUCCESS;
  }
  else {
    ATH_CONST_MSG_VERBOSE( "getTypeNameOfID({}) no associated type name found", id );
    return StatusCode::FAILURE;
  }
}
 

StatusCode 
ClassIDSvc::getTypeInfoNameOfID(const CLID& id, std::string& typeInfoName) const
{
  lock_t lock (m_mutex);
  maybeRescan();
 
  CLIDMap::const_iterator iID = m_clidMap.find(id);
  if (iID != m_clidMap.end()) {
    typeInfoName = iID->second.second;
    ATH_CONST_MSG_VERBOSE( "getTypeInfoNameOfID({}) type-info name is {}",
                           id, typeInfoName );
    return StatusCode::SUCCESS;
  }
  else {
    ATH_CONST_MSG_VERBOSE( "getTypeInfoNameOfID({}) no associated type-info name found", id );
    return StatusCode::FAILURE;
  }
}
 

StatusCode 
ClassIDSvc::getIDOfTypeName(const std::string& typeName, CLID& id) const
{
  lock_t lock (m_mutex);
  maybeRescan();
 
  NameMap::const_iterator iID = m_nameMap.find(typeName);
  if (iID != m_nameMap.end()) {
    id = iID->second;
    ATH_CONST_MSG_VERBOSE( "getIDOfTypeName({}) CLID is {}", typeName, id );
    return StatusCode::SUCCESS;
  }
  else if (tryNumeric (typeName, id)) {
    ATH_CONST_MSG_VERBOSE( "getIDOfTypeName({}) is a numeric CLID", typeName );
    return StatusCode::SUCCESS;
  }
  else {
    ATH_CONST_MSG_VERBOSE( "getIDOfTypeName({}) no associated CLID found", typeName );
    return StatusCode::FAILURE;
  }
}
 

StatusCode 
ClassIDSvc::getIDOfTypeInfoName(const std::string& typeInfoName,
                CLID& id) const
{
  lock_t lock (m_mutex);
  maybeRescan();
  NameMap::const_iterator iID = m_tiNameMap.find(typeInfoName);
  if (iID != m_tiNameMap.end()) {
    id = iID->second;
    ATH_CONST_MSG_VERBOSE( "getIDOfTypeInfoName({}) CLID is {}", typeInfoName, id );
    return StatusCode::SUCCESS;
  }
  else {
    ATH_CONST_MSG_VERBOSE( "getIDOfTypeInfoName({}) no associated CLID found", typeInfoName );
    return StatusCode::FAILURE;
  }
}
 

StatusCode 
ClassIDSvc::setTypeForID(const CLID& id,
                         const std::string& typeName,
                         const std::string& typeInfoName)
{
  lock_t lock (m_mutex);
  if (id < CLIDdetail::MINCLID || id > CLIDdetail::MAXCLID) {
    ATH_MSG_ERROR( "setTypeNameForID: input id {} is out of allowed range {} : {}",
                   id, CLIDdetail::MINCLID, CLIDdetail::MAXCLID );
    return StatusCode::FAILURE;
  }
  return uncheckedSetTypePackageForID(id, typeName, typeInfoName);
}
 
 
void 
ClassIDSvc::dump() const
{
  lock_t lock (m_mutex);
  ATH_MSG_INFO( "dump: in memory" );
 
  for (CLID clid : sortedIDs()) {
    auto it = m_clidMap.find (clid);
    if (it == m_clidMap.end()) {
      ATH_MSG_INFO( "CLID: {} - type name: NOT FOUND", clid );
    }
    else {
      ATH_MSG_INFO( "CLID: {} - type name: ", clid, it->second.first );
    }
  }
  ATH_MSG_INFO( "------------------------------" );
}
 
 
StatusCode 
ClassIDSvc::initialize()
{
  using namespace std::string_view_literals;
 
  ATH_MSG_VERBOSE( "Initializing {}", name() ) ;
 
  CHECK( Service::initialize() );
 
  // ignore CLIDs (for testing/debugging):
  if (const char* clid_ignore = std::getenv("ATLAS_CLID_IGNORE")) {
    m_clidIgnore.value().insert_range( CxxUtils::tokenizeInt(clid_ignore, ","sv) );
  }
 
  // set up the incident service:
  ServiceHandle<IIncidentSvc> pIncSvc ("IncidentSvc", name());
  CHECK( pIncSvc.retrieve() );
 
  pIncSvc->addListener(this, ModuleLoadedIncident::TYPE(), /*priority*/ 100);
  pIncSvc->release();
 
  CHECK( maybeRescan() );  // calls fillDB() if not already done
 
  return StatusCode::SUCCESS;
}
 
 
StatusCode
ClassIDSvc::reinitialize() {
  ATH_MSG_INFO( "RE-initializing {}", name() ) ;
  CHECK( fillDB() );
  return StatusCode::SUCCESS;
}
 
 
StatusCode 
ClassIDSvc::finalize()
{
  if (m_outputFileName != "NULL") {
    std::ofstream outfile( m_outputFileName );
    if ( !outfile ) {
      ATH_MSG_ERROR( "unable to open output CLIDDB file: {}", m_outputFileName.value() );
      return StatusCode::RECOVERABLE;
    } else {
      for (CLID clid : sortedIDs()) {
        const std::string& typeName = m_clidMap[clid].first;
        const std::string& tiName   = m_clidMap[clid].second;
        std::println (outfile, "{}; {}; {}", clid, typeName, tiName);
      }
      ATH_MSG_INFO( "finalize: wrote {} entries to output CLIDDB file: {}",
                    m_clidMap.size(), m_outputFileName.value() );
    }
  }
  return Service::finalize();
}
 
 
void ClassIDSvc::handle(const Incident &inc)
{
  lock_t lock (m_mutex);
  const ModuleLoadedIncident& modInc(dynamic_cast<const ModuleLoadedIncident&>(inc));
 
  getRegistryEntries(modInc.module());
}
 

ClassIDSvc::ClassIDSvc(const std::string& name,ISvcLocator* svc)
  : base_class(name,svc),
    m_clidDBPath(System::getEnv("DATAPATH"))
{
}
 
 
// Return all registered IDs in sorted order.
std::vector<CLID> ClassIDSvc::sortedIDs() const
{
  std::vector<CLID> ids;
  ids.reserve (m_clidMap.size());
  for (const auto& p : m_clidMap) {
    ids.push_back (p.first);
  }
  std::sort (ids.begin(), ids.end());
  return ids;
}
 

StatusCode
ClassIDSvc::fillDB() {
  bool allOK(true);
  for (const std::string& DBFile : m_DBFiles) {
    DirSearchPath::path clidDB(DBFile);
 
    if (clidDB.is_absolute()) {
      allOK = processCLIDDB(clidDB.string());
    } else {
      std::list<DirSearchPath::path> paths(m_clidDBPath.find_all(clidDB));
      if (paths.empty()) {
        ATH_MSG_DEBUG( "Could not resolve clid DB path " << clidDB
                       << " using DATAPATH. Skipping it." );
      } else {
        for (const auto& p : paths) {
          allOK &= processCLIDDB(p.string());
        }
      }
    }
  }
  return StatusCode(allOK);
}
 
 
bool
ClassIDSvc::processCLIDDB(const std::string& fileName)
{
  std::ifstream ifile(fileName);
  if (!ifile) {
    ATH_MSG_WARNING( "processCLIDDB: unable to open {}", fileName );
    return true;
  }
 
  bool allOK(true);
  unsigned int newEntries(0);
  std::string line;
  // Format: CLID;typeName[;typeInfoName]
  while (allOK && std::getline(ifile, line)) {
    std::vector<std::string> columns = CxxUtils::tokenize(line, ';');
    long id(-1);
    if (columns.size()>=2) {
      columns[0] = CxxUtils::trimWhiteSpaces(columns[0]);
      try {
        id = std::stol(columns[0]);
      } catch (const std::logic_error& e) {
        ATH_MSG_ERROR( "processCLIDDB: Can't cast [{}] to long (clid): {}",
                       columns[0], e.what() );
        allOK = false;
      }
 
      if (uncheckedSetTypePackageForID(id, columns[1],
                                       columns.size()>2 ? columns[2] : "")) {
        ++newEntries;
      }
    }
  }
 
  if (!allOK) {
    ATH_MSG_ERROR( "processCLIDDB: processing record '{}' from CLIDDB file: {}",
                   line, fileName );
  } else {
    ATH_MSG_DEBUG( "processCLIDDB: read {} entries from CLIDDB file: {}",
                   newEntries, fileName );
  }
 
  return allOK;
}
 
 
bool ClassIDSvc::getRegistryEntries(const std::string& moduleName)
{
  //not only this is fast, but is necessary to prevent recursion
  if (!CLIDRegistry::hasNewEntries()) return true;
 
  bool allOK(true);
  size_t newEntries(0);
  //to speed up processing we only take entries added to CLIDRegistry
  //since last call (thanks Niels!)
  for (const auto& [clid, typeName, typeInfoName] : CLIDRegistry::newEntries()) {
    ATH_MSG_VERBOSE( "reading [{}, {}, {}]", clid, typeName, typeInfoName);
    if (uncheckedSetTypePackageForID(clid, typeName, typeInfoName)) {
      ++newEntries;
    }
    else {
      allOK = false;
    }
  }
  
  if (allOK) {
    ATH_MSG_INFO( "getRegistryEntries: read {} CLIDRegistry entries for module {}",
                  newEntries, moduleName );
  } else {
    ATH_MSG_ERROR("getRegistryEntries: can not read  CLIDRegistry entries for module {}",
                  moduleName );
  }
 
  return allOK;
}
 
 
StatusCode 
ClassIDSvc::uncheckedSetTypePackageForID(const CLID& id, 
                                         const std::string& typeName,
                                         const std::string& typeInfoName)
{
  // process "raw" typeName
  std::string procName(typeName);
  procName = CxxUtils::trimWhiteSpaces(procName);
 
  if (procName.empty()) {
    ATH_MSG_ERROR( "Empty type name for CLID {}", id );
    return StatusCode::FAILURE;
  }
 
  if (m_clidIgnore.value().contains(id)) {
    ATH_MSG_WARNING( "Ignoring type '{}' with CLID {}", procName, id );
    return StatusCode::SUCCESS;
  }
 
  // assign typeInfoName
  std::string procTiName;
  if (typeInfoName.empty()) {
    procTiName = procName;
  }
  else {
    procTiName = typeInfoName;
    procTiName = CxxUtils::trimWhiteSpaces(procTiName);
  }
 
  // insert into CLID map
  const auto& [clid_it, clid_success] = m_clidMap.try_emplace(id, procName, procTiName);
  if (!clid_success && clid_it->second!=std::make_pair(procName,procTiName)) {
    ATH_MSG_ERROR( "Cannot set type {} for CLID {}: known type for this ID {}", 
                   std::make_pair(procName,procTiName), id, clid_it->second);
    return StatusCode::FAILURE;
  }
 
  // insert into type name map
  const auto& [name_it, name_success] = m_nameMap.try_emplace(procName, id);
  if (!name_success && name_it->second!=id) {
    ATH_MSG_ERROR( "Cannot set CLID {} for type name '{}': known CLID for this name {}",
                   id, procName, name_it->second);
    return StatusCode::FAILURE;
  }
 
  // insert into typeInfo map
  const auto& [info_it, info_success] = m_tiNameMap.try_emplace(procTiName, id);
  if (!info_success && info_it->second!=id) {
    ATH_MSG_ERROR( "Cannot set CLID {} for type-info name '{}' and type '{}': known CLID for this type-info name {}",
                   id, procTiName, procName, info_it->second);
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_VERBOSE( "Set type name '{}' for CLID {} with type-info name '{}'",
                   procName, id, procTiName);
 
  return StatusCode::SUCCESS;
}
 
 
bool ClassIDSvc::maybeRescan() const
{
  // thread-safe because calls are protected by mutex or during initialize
  ClassIDSvc* nc ATLAS_THREAD_SAFE = const_cast<ClassIDSvc*>(this);
 
  // read CLID database in case initialize() was not called yet (ATR-23634)
  [[maybe_unused]] static bool fillDB ATLAS_THREAD_SAFE = nc->fillDB().isSuccess();
 
  // make sure registry is up-to-date
  bool status = nc->getRegistryEntries ("ALL");
 
  return status && fillDB;
}