AthDictLoaderSvc Class Reference

#include <AthDictLoaderSvc.h>

Inheritance diagram for AthDictLoaderSvc:

Collaboration diagram for AthDictLoaderSvc:

Public Member Functions
	AthDictLoaderSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters: More...
virtual	~AthDictLoaderSvc ()
	Destructor: More...
virtual StatusCode	initialize () override
	Gaudi Service Implementation. More...
virtual StatusCode	finalize () override
virtual bool	has_type (const std::string &type_name) override
	check a Reflex dictionary exists for a given type More...
virtual bool	has_type (const std::type_info &typeinfo) override
	check a Reflex dictionary exists for a given type More...
virtual bool	has_type (CLID clid) override
	check a Reflex dictionary exists for a given type More...
virtual const RootType	load_type (const std::string &type_name, bool recursive=false) override
	retrieve a Reflex::Type by name (auto)loading the dictionary by any necessary means. More...
virtual const RootType	load_type (const std::type_info &typeinfo, bool recursive=false) override
	retrieve a Reflex::Type by std::type_info (auto)loading the dictionary by any necessary means. More...
virtual const RootType	load_type (CLID clid, bool recursive=false) override
	retrieve a Reflex::Type by name (auto)loading the dictionary by any necessary means. More...

Private Types
using	Memo_t = std::unordered_set< std::string >

Private Member Functions
	AthDictLoaderSvc ()
	Default constructor: More...
void	load_recursive (const RootType &typ)
void	load_recursive1 (const std::string &tnam, Memo_t &memo)
void	load_recursive1 (const RootType &typ, Memo_t &memo)

Private Attributes
const Ath::DsoDb *	m_dsodb
	dictionary of all known (reflex) types More...
ServiceHandle< IClassIDSvc >	m_clidSvc
	handle to a IClassIDSvc to handle loading of types by CLID More...
ServiceHandle< ITPCnvSvc >	m_tpCnvSvc

Detailed Description

Definition at line 34 of file AthDictLoaderSvc.h.

Member Typedef Documentation

Memo_t

using AthDictLoaderSvc::Memo_t = std::unordered_set<std::string>

private

Definition at line 117 of file AthDictLoaderSvc.h.

Constructor & Destructor Documentation

AthDictLoaderSvc() [1/2]

AthDictLoaderSvc::AthDictLoaderSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

Constructor with parameters:

Definition at line 38 of file AthDictLoaderSvc.cxx.

                                                              : 
  base_class( name, pSvcLocator ),
  m_dsodb (nullptr),
  m_clidSvc ("ClassIDSvc", name),
  m_tpCnvSvc("AthTPCnvSvc", name)
{
}

~AthDictLoaderSvc()

AthDictLoaderSvc::~AthDictLoaderSvc ( )

virtual

Destructor:

Definition at line 49 of file AthDictLoaderSvc.cxx.

{}

AthDictLoaderSvc() [2/2]

AthDictLoaderSvc::AthDictLoaderSvc ( )

private

Default constructor:

Member Function Documentation

finalize()

StatusCode AthDictLoaderSvc::finalize ( )

overridevirtual

Definition at line 70 of file AthDictLoaderSvc.cxx.

{
  ATH_MSG_INFO ("in finalize...");
  return StatusCode::SUCCESS;
}

has_type() [1/3]

bool AthDictLoaderSvc::has_type ( CLID  clid )

overridevirtual

check a Reflex dictionary exists for a given type

Definition at line 103 of file AthDictLoaderSvc.cxx.

{
  bool ret = false;
  std::string name = "<N/A>";
  if (m_clidSvc->getTypeNameOfID(clid, name).isSuccess()) {
    ret = has_type (name);
    if (ret) {
      return ret;
    }
  }
 
  // try out the typeinfoname...
  if (m_clidSvc->getTypeInfoNameOfID(clid, name).isSuccess()) {
    ret = has_type (name);
    if (ret) {
      return ret;
    }
  }
  
  return ret;
}

has_type() [2/3]

bool AthDictLoaderSvc::has_type ( const std::string &  type_name )

overridevirtual

check a Reflex dictionary exists for a given type

Definition at line 79 of file AthDictLoaderSvc.cxx.

{
  if (!m_dsodb)
    return false;
 
  bool has_type = m_dsodb->has_type(type_name);
  if (!has_type) {
    ATH_MSG_DEBUG ("no reflex dict. for type [" << type_name << "]");
  }
 
  return has_type;
}

has_type() [3/3]

bool AthDictLoaderSvc::has_type ( const std::type_info &  typeinfo )

overridevirtual

check a Reflex dictionary exists for a given type

Definition at line 95 of file AthDictLoaderSvc.cxx.

{
  return has_type (System::typeinfoName(typeinfo).c_str());
}

initialize()

StatusCode AthDictLoaderSvc::initialize ( )

overridevirtual

Gaudi Service Implementation.

Definition at line 54 of file AthDictLoaderSvc.cxx.

{
  ATH_MSG_INFO ("in initialize...");
  m_dsodb = Ath::DsoDb::instance();
  if (!m_dsodb) {
    ATH_MSG_ERROR("could not acquire Dso-registry");
    return StatusCode::FAILURE;
  }
  ATH_MSG_INFO ("acquired Dso-registry");
 
  ATH_CHECK( m_clidSvc.retrieve() );
  ATH_CHECK( m_tpCnvSvc.retrieve() );
 
  return StatusCode::SUCCESS;
}

load_recursive()

void AthDictLoaderSvc::load_recursive ( const RootType &  typ )

private

Definition at line 204 of file AthDictLoaderSvc.cxx.

{
  Memo_t memo;
  RootUtils::WithRootErrorHandler hand ([] (int, bool, const char*, const char*) { return false; });
  load_recursive1 (typ, memo);
}

load_recursive1() [1/2]

void AthDictLoaderSvc::load_recursive1 ( const RootType &  typ, Memo_t &  memo  )

private

Definition at line 222 of file AthDictLoaderSvc.cxx.

{
  if (!typ) return;
  if (typ.IsFundamental() || typ.IsPointer() || typ.IsEnum()) return;
  if (!typ.IsClass()) return;
  std::string nam = typ.Name();
  if (!memo.insert (nam).second) return;
  if (nam == "string" || nam == "std::string" ||
      startsWith (nam, "basic_string<") ||
      startsWith (nam, "std::basic_string<"))
  {
    return;
  }
  if (startsWith (nam, "vector<") || startsWith (nam, "std::vector<")) {
    std::string eltclass;
    {
      // Protect against data race inside TClassEdit.
      // https://github.com/root-project/root/issues/10353
      // Should be fixed in root 6.26.02.
      R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
      TClassEdit::TSplitType split (nam.c_str());
      if (split.fElements.size() > 1) {
        eltclass = split.fElements[1];
      }
    }
    if (!eltclass.empty()) {
      load_recursive1 (eltclass, memo);
      return;
    }
 
  }
  else if (startsWith (nam, "DataVector<")) {
    std::string eltclass;
    {
      // Protect against data race inside TClassEdit.
      // https://github.com/root-project/root/issues/10353
      // Should be fixed in root 6.26.02.
      R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
      TClassEdit::TSplitType split (nam.c_str());
      if (split.fElements.size() > 1) {
        eltclass = split.fElements[1];
      }
    }
    if (!eltclass.empty()) {
      load_recursive1 (eltclass, memo);
      return;
    }
  }
  else if (startsWith (nam, "pair<") || startsWith (nam, "std::pair<")) {
    std::string pclass1, pclass2;
    {
      // Protect against data race inside TClassEdit.
      // https://github.com/root-project/root/issues/10353
      // Should be fixed in root 6.26.02.
      R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
      TClassEdit::TSplitType split (nam.c_str());
      if (split.fElements.size() > 2) {
        pclass1 = split.fElements[1];
        pclass2 = split.fElements[2];
      }
    }
    if (!pclass1.empty()) {
      load_recursive1 (pclass1, memo);
      load_recursive1 (pclass2, memo);
      return;
    }
  }
  else if (startsWith (nam, "map<") || startsWith (nam, "std::map<")) {
    std::string pclass1, pclass2;
    {
      // Protect against data race inside TClassEdit.
      // https://github.com/root-project/root/issues/10353
      // Should be fixed in root 6.26.02.
      R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
      TClassEdit::TSplitType split (nam.c_str());
      if (split.fElements.size() > 2) {
        pclass1 = split.fElements[1];
        pclass2 = split.fElements[2];
      }
    }
    if (!pclass1.empty()) {
      load_recursive1 (pclass1, memo);
      load_recursive1 (pclass2, memo);
      // For ROOT persistency.
      std::string pname = "std::pair<" + pclass1 + "," + pclass2 + ">";
      load_type (pname);
      return;
    }
  }
  else if (startsWith (nam, "LArConditionsContainer<")) {
    std::string pname;
    {
      // Protect against data race inside TClassEdit.
      // https://github.com/root-project/root/issues/10353
      // Should be fixed in root 6.26.02.
      R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
      TClassEdit::TSplitType split (nam.c_str());
      if (split.fElements.size() > 1) {
        pname = "LArConditionsSubset<" + split.fElements[1] + ">";
      }
    }
    if (!pname.empty()) {
      load_recursive1 (pname, memo);
 
      std::unique_ptr<ITPCnvBase> tpcnv = m_tpCnvSvc->t2p_cnv_unique (pname);
      if (tpcnv) {
        load_type (tpcnv->persistentTInfo(), true);
      }
      return;
    }
  }
 
  size_t nbase = typ.BaseSize();
  for (size_t i = 0; i < nbase; i++) {
    load_recursive1 (typ.BaseAt(i).Name(), memo);
  }
 
  size_t nmem = typ.DataMemberSize();
  for (size_t i = 0; i < nmem; i++) {
    RootType mem = typ.DataMemberAt(i).TypeOf();
    load_recursive1 (mem, memo);
  }
}

load_recursive1() [2/2]

void AthDictLoaderSvc::load_recursive1 ( const std::string &  tnam, Memo_t &  memo  )

private

Definition at line 211 of file AthDictLoaderSvc.cxx.

{
  if (startsWith (tnam, "const ")) {
    load_recursive1 (RootType::ByNameNoQuiet (tnam.substr (6, std::string::npos)),
                     memo);
  }
  else {
    load_recursive1 (RootType::ByNameNoQuiet (tnam), memo);
  }
}

load_type() [1/3]

const RootType AthDictLoaderSvc::load_type ( CLID  clid, bool  recursive = false  )

overridevirtual

retrieve a Reflex::Type by name (auto)loading the dictionary by any necessary means.

If recursive is true, then recursively load contained types.

Definition at line 166 of file AthDictLoaderSvc.cxx.

{
  std::string name = "<N/A>";
  if (!m_clidSvc->getTypeNameOfID(clid, name).isSuccess()) {
    ATH_MSG_INFO ("could not retrieve typename for clid [" << clid << "]");
    // try out the bare std::type_info if available...
    const SG::BaseInfoBase* bib = SG::BaseInfoBase::find(clid);
    if (bib) {
      return load_type(bib->typeinfo(), recursive);
    }
    // fail early...
    return RootType();
  }
  
  ATH_MSG_DEBUG("loading [" << name << " (from clid="<<clid<<")]...");
 
  RootType type = load_type(name, recursive);
  if (type) {
    return type;
  }
 
  // try out the typeinfo-name
  m_clidSvc->getTypeInfoNameOfID(clid, name).ignore();
  type = load_type(name, recursive);
  if (type) {
    return type;
  }
 
  // try out the bare std::type_info if available...
  const SG::BaseInfoBase* bib = SG::BaseInfoBase::find(clid);
  if (bib) {
    return load_type(bib->typeinfo(), recursive);
  }
  // cppcheck-suppress identicalConditionAfterEarlyExit
  return type;
}

load_type() [2/3]

const RootType AthDictLoaderSvc::load_type ( const std::string &  type_name, bool  recursive = false  )

overridevirtual

retrieve a Reflex::Type by name (auto)loading the dictionary by any necessary means.

If recursive is true, then recursively load contained types.

Definition at line 130 of file AthDictLoaderSvc.cxx.

{
  ATH_MSG_DEBUG ("loading [" << type_name << "]...");
 
  // MN: short-cutting all the dance with type names done in DSODB...
  // may need verification
  // return RootType::ByName (m_dsodb->load_type(type_name));
  RootType rt = RootType::ByNameNoQuiet(type_name);
 
  if (recursive) {
    load_recursive (rt);
  }
  return rt;
}

load_type() [3/3]

const RootType AthDictLoaderSvc::load_type ( const std::type_info &  typeinfo, bool  recursive = false  )

overridevirtual

retrieve a Reflex::Type by std::type_info (auto)loading the dictionary by any necessary means.

This method is preferred over the above one as it is guaranteed to succeed IF the dictionary for that type has been generated. If recursive is true, then recursively load contained types.

Definition at line 153 of file AthDictLoaderSvc.cxx.

{
  ATH_MSG_DEBUG 
    ("loading [" << System::typeinfoName(typeinfo) << " (from typeinfo)]...");
  return load_type (System::typeinfoName(typeinfo), recursive);
}

Member Data Documentation

m_clidSvc

ServiceHandle<IClassIDSvc> AthDictLoaderSvc::m_clidSvc

private

handle to a IClassIDSvc to handle loading of types by CLID

Definition at line 112 of file AthDictLoaderSvc.h.

m_dsodb

const Ath::DsoDb* AthDictLoaderSvc::m_dsodb

private

dictionary of all known (reflex) types

Definition at line 108 of file AthDictLoaderSvc.h.

m_tpCnvSvc

ServiceHandle<ITPCnvSvc> AthDictLoaderSvc::m_tpCnvSvc

private

Definition at line 114 of file AthDictLoaderSvc.h.

---

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

• AthDictLoaderSvc.h
• AthDictLoaderSvc.cxx