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 StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface) 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...
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

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

Friends
class	SvcFactory< AthDictLoaderSvc >

Detailed Description

Definition at line 35 of file AthDictLoaderSvc.h.

Member Typedef Documentation

Memo_t

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

private

Definition at line 126 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.

                                                              : 
  ::AthService( 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

Implements IDictLoaderSvc.

Definition at line 121 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

Implements IDictLoaderSvc.

Definition at line 97 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

Implements IDictLoaderSvc.

Definition at line 113 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;
}

interfaceID()

const InterfaceID & AthDictLoaderSvc::interfaceID ( )

inlinestatic

Definition at line 137 of file AthDictLoaderSvc.h.

{ 
  return IDictLoaderSvc::interfaceID(); 
}

load_recursive()

void AthDictLoaderSvc::load_recursive ( const RootType &  typ )

private

Definition at line 222 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 240 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 229 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.

Implements IDictLoaderSvc.

Definition at line 184 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.

Implements IDictLoaderSvc.

Definition at line 148 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.

Implements IDictLoaderSvc.

Definition at line 171 of file AthDictLoaderSvc.cxx.

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

msg() [1/2]

MsgStream& AthCommonMsg< Service >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Service >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< Service >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

queryInterface()

StatusCode AthDictLoaderSvc::queryInterface ( const InterfaceID &  riid, void **  ppvInterface  )

overridevirtual

Definition at line 82 of file AthDictLoaderSvc.cxx.

{
  if ( IDictLoaderSvc::interfaceID().versionMatch(riid) ) {
    *ppvInterface = dynamic_cast<IDictLoaderSvc*>(this);
  } else {
    // Interface is not directly available : try out a base class
    return ::AthService::queryInterface(riid, ppvInterface);
  }
  addRef();
  return StatusCode::SUCCESS;
}

Friends And Related Function Documentation

SvcFactory< AthDictLoaderSvc >

friend class SvcFactory< AthDictLoaderSvc >

friend

Definition at line 137 of file AthDictLoaderSvc.h.

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 121 of file AthDictLoaderSvc.h.

m_dsodb

const Ath::DsoDb* AthDictLoaderSvc::m_dsodb

private

dictionary of all known (reflex) types

Definition at line 117 of file AthDictLoaderSvc.h.

m_tpCnvSvc

ServiceHandle<ITPCnvSvc> AthDictLoaderSvc::m_tpCnvSvc

private

Definition at line 123 of file AthDictLoaderSvc.h.

---

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

• AthDictLoaderSvc.h
• AthDictLoaderSvc.cxx