ClassIDSvc Class Reference

a service to manage and verify CLID assignments in athena. More...

#include <ClassIDSvc.h>

Inheritance diagram for ClassIDSvc:

Collaboration diagram for ClassIDSvc:

Public Member Functions
IClassIDSvc interfaces.
virtual CLID	nextAvailableID () const override
	get next available CLID
virtual bool	isIDInUse (const CLID &id) const override
	check if id is used
virtual bool	isNameInUse (const std::string &name) const override
	check if id is used
virtual StatusCode	getTypeNameOfID (const CLID &id, std::string &typeName) const override
	get type name associated with clID (if any)
virtual StatusCode	getTypeInfoNameOfID (const CLID &id, std::string &typeInfoName) const override
	get user assigned type-info name associated with clID
virtual StatusCode	getIDOfTypeName (const std::string &typeName, CLID &id) const override
	get id associated with type name (if any)
virtual StatusCode	getIDOfTypeInfoName (const std::string &typeInfoName, CLID &id) const override
	get id associated with type-info name (if any)
virtual StatusCode	setTypeForID (const CLID &id, const std::string &typeName, const std::string &typeInfoName="") override
	associate type name, package info and type-info name with clID
Debugging methods.
void	dump () const
	dump to MsgStream contents of in memory DB

Private Types
typedef std::pair< std::string, std::string >	TypeName
typedef std::unordered_map< CLID, TypeName >	CLIDMap
typedef std::unordered_map< std::string, CLID >	NameMap

Properties
typedef std::mutex	mutex_t
typedef std::lock_guard< mutex_t >	lock_t
Gaudi::Property< std::vector< std::string > >	m_DBFiles
Gaudi::Property< std::string >	m_outputFileName
Gaudi::Property< std::set< CLID > >	m_clidIgnore
CLIDMap	m_clidMap
NameMap	m_nameMap
NameMap	m_tiNameMap
DirSearchPath	m_clidDBPath
	The path is which clid db files are to be searched (DATAPATH).
mutex_t	m_mutex

Gaudi methods.
virtual StatusCode	initialize () override
	Gaudi Service Implementation.
virtual StatusCode	reinitialize () override
virtual StatusCode	finalize () override
	dump CLIDmap to outputFileName;
void	handle (const Incident &inc) override
	implement IIncidentListener
	ClassIDSvc (const std::string &name, ISvcLocator *svc)
	Standard Constructor.
std::vector< CLID >	sortedIDs () const
	Return all registered IDs in sorted order.
StatusCode	fillDB ()
	get clids from CLIDDB and from registry entries
bool	processCLIDDB (const std::string &fileName)
	load clid/names from a "db" file
bool	getRegistryEntries (const std::string &moduleName)
	load clid/names from a DLL registry
StatusCode	uncheckedSetTypePackageForID (const CLID &id, const std::string &typeName, const std::string &typeInfoName)
	associate type name with clID w/o checking CLID range
bool	maybeRescan () const
	Test to see if anything new has been added to the registry.

Detailed Description

a service to manage and verify CLID assignments in athena.

(clid, class_name) entries are loaded at init from the list of files specifies in "CLIDDBFiles", and from the CLID_Registry of every library. Optionally the resulting m_clidMap can be dumped to "OutputFileName" at finalize time.

Definition at line 37 of file ClassIDSvc.h.

Member Typedef Documentation

CLIDMap

typedef std::unordered_map<CLID, TypeName> ClassIDSvc::CLIDMap

private

Definition at line 41 of file ClassIDSvc.h.

lock_t

typedef std::lock_guard<mutex_t> ClassIDSvc::lock_t

private

Definition at line 138 of file ClassIDSvc.h.

mutex_t

typedef std::mutex ClassIDSvc::mutex_t

private

Definition at line 137 of file ClassIDSvc.h.

NameMap

typedef std::unordered_map<std::string, CLID> ClassIDSvc::NameMap

private

Definition at line 42 of file ClassIDSvc.h.

TypeName

typedef std::pair<std::string, std::string> ClassIDSvc::TypeName

private

Definition at line 40 of file ClassIDSvc.h.

Constructor & Destructor Documentation

ClassIDSvc()

ClassIDSvc::ClassIDSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Standard Constructor.

Definition at line 285 of file ClassIDSvc.cxx.

  : base_class(name,svc),
    m_clidDBPath(System::getEnv("DATAPATH"))
{
}

Member Function Documentation

dump()

void ClassIDSvc::dump

(

)

const

dump to MsgStream contents of in memory DB

Definition at line 200 of file ClassIDSvc.cxx.

{
  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( "------------------------------" );
}

fillDB()

StatusCode ClassIDSvc::fillDB ( )

private

get clids from CLIDDB and from registry entries

Process the various clid dbs according to user's request.

Definition at line 307 of file ClassIDSvc.cxx.

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

finalize()

StatusCode ClassIDSvc::finalize ( )

overridevirtual

dump CLIDmap to outputFileName;

Definition at line 254 of file ClassIDSvc.cxx.

{
  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();
}

getIDOfTypeInfoName()

StatusCode ClassIDSvc::getIDOfTypeInfoName ( const std::string & typeInfoName, CLID & id ) const

overridevirtual

get id associated with type-info name (if any)

Definition at line 165 of file ClassIDSvc.cxx.

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

getIDOfTypeName()

StatusCode ClassIDSvc::getIDOfTypeName ( const std::string & typeName, CLID & id ) const

overridevirtual

get id associated with type name (if any)

Definition at line 141 of file ClassIDSvc.cxx.

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

getRegistryEntries()

bool ClassIDSvc::getRegistryEntries ( const std::string & moduleName )

private

load clid/names from a DLL registry

Definition at line 375 of file ClassIDSvc.cxx.

{
  //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;
}

getTypeInfoNameOfID()

StatusCode ClassIDSvc::getTypeInfoNameOfID ( const CLID & id, std::string & typeInfoName ) const

overridevirtual

get user assigned type-info name associated with clID

get type name associated with clID (if any)

Definition at line 120 of file ClassIDSvc.cxx.

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

getTypeNameOfID()

StatusCode ClassIDSvc::getTypeNameOfID ( const CLID & id, std::string & typeName ) const

overridevirtual

get type name associated with clID (if any)

Definition at line 100 of file ClassIDSvc.cxx.

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

handle()

void ClassIDSvc::handle ( const Incident & inc )

override

implement IIncidentListener

Definition at line 275 of file ClassIDSvc.cxx.

{
  lock_t lock (m_mutex);
  const ModuleLoadedIncident& modInc(dynamic_cast<const ModuleLoadedIncident&>(inc));
 
  getRegistryEntries(modInc.module());
}

initialize()

StatusCode ClassIDSvc::initialize ( )

overridevirtual

Gaudi Service Implementation.

Definition at line 219 of file ClassIDSvc.cxx.

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

isIDInUse()

bool ClassIDSvc::isIDInUse ( const CLID & id ) const

overridevirtual

check if id is used

Definition at line 83 of file ClassIDSvc.cxx.

                                           {
  lock_t lock (m_mutex);
  maybeRescan();
  return m_clidMap.find(id) != m_clidMap.end();
}

isNameInUse()

bool ClassIDSvc::isNameInUse ( const std::string & name ) const

overridevirtual

check if id is used

Definition at line 91 of file ClassIDSvc.cxx.

                                                    {
  lock_t lock (m_mutex);
  maybeRescan();
  return m_nameMap.find(name) != m_nameMap.end();
}

maybeRescan()

bool ClassIDSvc::maybeRescan ( ) const

private

Test to see if anything new has been added to the registry.

Definition at line 466 of file ClassIDSvc.cxx.

{
  // 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;
}

nextAvailableID()

CLID ClassIDSvc::nextAvailableID ( ) const

overridevirtual

get next available CLID

Exceptions

std::runtime_error	if no CLID can be allocated virtual CLID nextAvailableID() const;
std::runtime_error	if no CLID can be allocated

Definition at line 64 of file ClassIDSvc.cxx.

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

processCLIDDB()

bool ClassIDSvc::processCLIDDB ( const std::string & fileName )

private

load clid/names from a "db" file

Definition at line 331 of file ClassIDSvc.cxx.

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

reinitialize()

StatusCode ClassIDSvc::reinitialize ( )

overridevirtual

Definition at line 246 of file ClassIDSvc.cxx.

                         {
  ATH_MSG_INFO( "RE-initializing {}", name() ) ;
  CHECK( fillDB() );
  return StatusCode::SUCCESS;
}

setTypeForID()

StatusCode ClassIDSvc::setTypeForID ( const CLID & id, const std::string & typeName, const std::string & typeInfoName = "" )

overridevirtual

associate type name, package info and type-info name with clID

associate type name with clID

Definition at line 185 of file ClassIDSvc.cxx.

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

sortedIDs()

std::vector< CLID > ClassIDSvc::sortedIDs ( ) const

private

Return all registered IDs in sorted order.

Definition at line 293 of file ClassIDSvc.cxx.

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

uncheckedSetTypePackageForID()

StatusCode ClassIDSvc::uncheckedSetTypePackageForID ( const CLID & id, const std::string & typeName, const std::string & typeInfoName )

private

associate type name with clID w/o checking CLID range

Definition at line 407 of file ClassIDSvc.cxx.

{
  // 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;
}

Member Data Documentation

m_clidDBPath

DirSearchPath ClassIDSvc::m_clidDBPath

private

The path is which clid db files are to be searched (DATAPATH).

Definition at line 134 of file ClassIDSvc.h.

m_clidIgnore

Gaudi::Property<std::set<CLID> > ClassIDSvc::m_clidIgnore

private

Initial value:

{this, "IgnoreCLIDs", {},
    "Set of CLIDs to ignore. Can also be set via the ATLAS_CLID_IGNORE environment variable (comma-separated). "
    "Useful for testing the removal of EDM classes in a local build."}

Definition at line 125 of file ClassIDSvc.h.

                                          {this, "IgnoreCLIDs", {},
    "Set of CLIDs to ignore. Can also be set via the ATLAS_CLID_IGNORE environment variable (comma-separated). "
    "Useful for testing the removal of EDM classes in a local build."};

m_clidMap

CLIDMap ClassIDSvc::m_clidMap

private

Definition at line 129 of file ClassIDSvc.h.

m_DBFiles

Gaudi::Property<std::vector<std::string> > ClassIDSvc::m_DBFiles

private

Initial value:

{this, "CLIDDBFiles", {"clid.db"},
    "List of db files with (CLID, class_name) entries. Loaded at init in svc maps. Files are looked up in DATAPATH",
    "OrderedSet<std::string>"}

Definition at line 118 of file ClassIDSvc.h.

                                               {this, "CLIDDBFiles", {"clid.db"},
    "List of db files with (CLID, class_name) entries. Loaded at init in svc maps. Files are looked up in DATAPATH",
    "OrderedSet<std::string>"};

m_mutex

mutex_t ClassIDSvc::m_mutex

mutableprivate

Definition at line 139 of file ClassIDSvc.h.

m_nameMap

NameMap ClassIDSvc::m_nameMap

private

Definition at line 130 of file ClassIDSvc.h.

m_outputFileName

Gaudi::Property<std::string> ClassIDSvc::m_outputFileName

private

Initial value:

{this, "OutputFileName", "NULL",
    "Path to clid.db file for writing. By default ('NULL') to not create the file."}

Definition at line 122 of file ClassIDSvc.h.

                                           {this, "OutputFileName", "NULL",
    "Path to clid.db file for writing. By default ('NULL') to not create the file."};

m_tiNameMap

NameMap ClassIDSvc::m_tiNameMap

private

Definition at line 131 of file ClassIDSvc.h.

---

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

• ClassIDSvc.h
• ClassIDSvc.cxx