Ath::DsoDb Class Reference

helper class to query rootmap files and extract their content More...

#include <DsoDb.h>

Collaboration diagram for Ath::DsoDb:

Public Types
typedef std::vector< std::string >	Libs_t
typedef std::unordered_map< std::string, Libs_t >	DsoMap_t

Public Member Functions
	~DsoDb ()
	Destructor: More...
const std::vector< std::string > &	dso_files () const
	list of all dsomap/rootmap files we know about More...
const DsoMap_t &	pf () const
	repository of plugin factories More...
const DsoMap_t &	db () const
	repository of components More...
bool	has_type (const std::string &type_name) const
std::string load_type	ATLAS_NOT_THREAD_SAFE (const std::string &type_name) const
std::vector< std::string >	capabilities (const std::string &libname) const
	list of reflex-types associated with a library name More...
DsoMap_t	duplicates (const std::string &libname, bool pedantic=false) const
	list of libraries hosting duplicate reflex-types More...
DsoMap_t	dict_duplicates (bool pedantic=false) const
	table of dict-duplicates: {type: [lib1, lib2, ...]} More...
DsoMap_t	pf_duplicates (bool pedantic=false) const
	table of plugin-factories-duplicates: {type: [lib1, lib2, ...]} More...
Libs_t	libs (bool detailed=false) const
	list of all libraries we know about More...
DsoMap_t	content (bool pedantic) const
	return the table {type: [lib1, ...]} - concatenation of all dict-entries and plugin-factories entries. More...

Static Public Member Functions
static std::vector< std::string >	py_keys_from (const Ath::DsoDb::DsoMap_t &m)
static std::vector< std::vector< std::string > >	py_vals_from (const Ath::DsoDb::DsoMap_t &m)
static const DsoDb *	instance ()
	factory for the DsoDb More...

Private Member Functions
void	build_repository ()
	initialize the repository of dso file names More...
void	get_dups (DsoMap_t &dups, const DsoMap_t &db, bool pedantic) const
	get the duplicates for a given repository of components More...
RootType rflx_type	ATLAS_NOT_THREAD_SAFE (const std::string &type_name) const
	load the reflex type after having loaded the hosting library More...
	DsoDb ()
	Default constructor: More...
	DsoDb (const DsoDb &rhs)
	Copy constructor: More...
DsoDb &	operator= (const DsoDb &rhs)
	Assignment operator: More...

Private Attributes
DsoMap_t	m_pf
	repository of plugin factories More...
DsoMap_t	m_db
	repository of components More...
std::vector< std::string >	m_dsofiles
	list of dsofiles More...

Detailed Description

helper class to query rootmap files and extract their content

Definition at line 30 of file DsoDb.h.

Member Typedef Documentation

DsoMap_t

typedef std::unordered_map<std::string, Libs_t> Ath::DsoDb::DsoMap_t

Definition at line 37 of file DsoDb.h.

Libs_t

typedef std::vector<std::string> Ath::DsoDb::Libs_t

Definition at line 36 of file DsoDb.h.

Constructor & Destructor Documentation

~DsoDb()

Ath::DsoDb::~DsoDb

(

)

Destructor:

Definition at line 255 of file DsoDb.cxx.

{}

DsoDb() [1/2]

Ath::DsoDb::DsoDb ( )

private

Default constructor:

Definition at line 245 of file DsoDb.cxx.

             :
  m_pf(),
  m_db(),
  m_dsofiles()
{
  build_repository();
}

DsoDb() [2/2]

Ath::DsoDb::DsoDb ( const DsoDb &  rhs )

private

Copy constructor:

Member Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/2]

std::string load_type Ath::DsoDb::ATLAS_NOT_THREAD_SAFE

(

const std::string &

type_name

)

const

ATLAS_NOT_THREAD_SAFE() [2/2]

RootType rflx_type Ath::DsoDb::ATLAS_NOT_THREAD_SAFE ( const std::string &  type_name ) const

private

load the reflex type after having loaded the hosting library

build_repository()

void Ath::DsoDb::build_repository ( )

private

initialize the repository of dso file names

Definition at line 292 of file DsoDb.cxx.

{
 // std::cerr << "::build_repository...\n";
 
  typedef boost::tokenizer<boost::char_separator<char> > Tokenizer_t;
  typedef std::vector<fs::path> Paths_t;
 
  std::set<std::string> dsofiles;
 
  std::string dsopath = System::getEnv("LD_LIBRARY_PATH");
  std::string rootsys = System::getEnv("ROOTSYS");
 
  Tokenizer_t tok(dsopath, boost::char_separator<char>(":"));
 
  for (Tokenizer_t::iterator itr = tok.begin(), iend = tok.end();
       itr != iend;
       ++itr) {
    //std::cerr << "--[" << *itr << "]...\n";
    if (itr->starts_with(rootsys)) {
      continue;
    }
    fs::path p(*itr);
    if (!std::filesystem::exists(*itr)) {
      continue;
    }
    Paths_t dir_content {fs::directory_iterator(p),
                         fs::directory_iterator()};
    std::sort(dir_content.begin(),
              dir_content.end());
    for (Paths_t::iterator ipath = dir_content.begin(),
           ipath_end = dir_content.end();
         ipath != ipath_end;
         ++ipath) {
      const fs::path& dsomap = *ipath;
 
      bool is_components = false;
      if (dsomap.extension() == Components)
        is_components = true;
      else if (dsomap.extension() != RootMap)
        continue;
 
      if (!fs::exists(dsomap)) continue;
 
      //std::cerr << "=== [" << dso << "] ===\n";
      dsofiles.insert(dsomap.c_str());
      std::ifstream f(dsomap.c_str());
      int line_nbr = -1;
      std::string lastlib;
      while (f) {
        line_nbr += 1;
        std::string line;
        std::getline(f, line);
        boost::algorithm::trim(line);
 
        std::string libname;
        std::string dso_key;
        if ( line.empty() )
          continue;
 
        else if (line.compare (0, 8, "Library.")==0) {
          Strings_t ll;
          boost::algorithm::split(ll, line, 
                                  boost::is_any_of(" "),
                                  boost::token_compress_on);
          if (ll.size() < 2) {
            std::cerr << "DsoDb:: **error** could not parse " 
                      << dsomap << ":" << line_nbr
                      << "\n"
                      << "DsoDb:: (some) reflex-dicts may fail to be autoloaded"
                      << "\n";
            continue;
          }
          libname = ll[1];
          if (::is_rootcint_dict(libname)) {
            continue;
          }
          dso_key = ll[0];
          libname = ::getlibname(libname);
          boost::algorithm::replace_all(dso_key, "Library.", "");
          boost::algorithm::replace_all(dso_key, ":", "");
          std::replace(dso_key.begin(), dso_key.end(), '@', ':');
          std::replace(dso_key.begin(), dso_key.end(), '-', ' ');
        }
 
        else if (line[0] == '[') {
          libname = line.substr (1, line.size()-2);
          boost::algorithm::trim (libname);
          if (::is_rootcint_dict(libname)) {
            lastlib.clear();
            continue;
          }
          if (!libname.empty())
            lastlib = ::getlibname (libname);
          continue;
        }
 
        else if (line.compare(0, 8, "# --End ")==0) {
           lastlib.clear();
           continue;
        }
 
        else if (line.compare(0, 6, "class ")==0) {
          libname = lastlib;
          line.erase (0, 6);
          dso_key = std::move(line);
        }
 
        else if (is_components && line.compare(0, 3, "lib") ==0) {
          std::string::size_type pos = line.find (':');
          if (pos == std::string::npos) continue;
          libname = line.substr(0, pos);
          line.erase (0, pos+1);
          dso_key = std::move(line);
 
          if (dso_key.compare(0, 6, "_PERS_")==0 ||
              dso_key.compare(0, 7, "_TRANS_")==0)
            continue;
 
          if (libname.find ("AthenaPoolPoolCnv") != std::string::npos)
            continue;
        }
 
        if (libname.empty() || dso_key.empty()) continue;
 
        const std::string fullpath_libname = to_string(dsomap.parent_path() / fs::path(libname));
 
        // std::cerr << " [" << line << "] -> [" << dso_key << "] [" << libname << "]\n";
 
        DsoMap_t *db = NULL;
        if (dso_key.starts_with(PluginNs) || is_components) {
          db = &m_pf;
        } else {
          db = &m_db;
        }
        if (db->find(dso_key) == db->end()) {
          db->insert(std::make_pair(dso_key, Strings_t()));
        }
        (*db)[dso_key].push_back(std::move(fullpath_libname));
      }
      // std::cerr << "=== [" << dso << "] === [EOF]\n";
    }
    //std::cerr << "--[" << *itr << "]... [done]\n";
  }
  
  m_dsofiles.reserve(dsofiles.size());
  std::copy(dsofiles.begin(), dsofiles.end(), std::back_inserter(m_dsofiles));
 
  // std::cerr << "::build_repository... [done]\n";
  return;
}

capabilities()

std::vector< std::string > Ath::DsoDb::capabilities

(

const std::string &

libname

)

const

list of reflex-types associated with a library name

Definition at line 444 of file DsoDb.cxx.

{
  fs::path p(libname_);
 
  const std::string libname = ::getlibname(to_string(p.filename()));
  std::set<std::string> caps;
  const DsoMap_t* dbs[] = { &m_pf, &m_db };
 
  for (std::size_t i = 0, imax = 2; i < imax; ++i) {
    const DsoMap_t* db = dbs[i];
    for (DsoMap_t::const_iterator idb = db->begin(), iend=db->end();
         idb != iend;
         ++idb) {
      for (Libs_t::const_iterator ilib = idb->second.begin(),
             ilibend = idb->second.end();
           ilib != ilibend;
           ++ilib) {
        fs::path lib(*ilib);
        if (to_string(lib.filename()) == libname) {
          caps.insert(idb->first);
        }
      }
    }
  }
 
  return std::vector<std::string>(caps.begin(), caps.end());
}

content()

DsoDb::DsoMap_t Ath::DsoDb::content

(

bool

pedantic

)

const

return the table {type: [lib1, ...]} - concatenation of all dict-entries and plugin-factories entries.

Parameters

<tt>pedantic</tt>

if true, retrieves the library's full path

Definition at line 558 of file DsoDb.cxx.

{
  DsoMap_t db;
 
  const DsoMap_t* dbs[] = { &m_pf, &m_db };
  for (std::size_t i = 0, imax = 2; i < imax; ++i) {
    const DsoMap_t& d = *dbs[i];
    for (DsoMap_t::const_iterator idb = d.begin(), idbend=d.end();
         idb != idbend;
         ++idb) {
      if (pedantic) {
        db[idb->first] = idb->second;
      } else {
        Libs_t libs;
        std::set<std::string> baselibs;
        for (Libs_t::const_iterator 
               ilib = idb->second.begin(),
               ilibend= idb->second.end();
             ilib != ilibend;
             ++ilib) {
          const std::string baselib = to_string(fs::path(*ilib).filename());
          if (baselibs.find(baselib) == baselibs.end()) {
            libs.push_back(*ilib);
            baselibs.insert(std::move(baselib));
          }
        }
        db[idb->first] = std::move(libs);
      }
    }
  }
 
  return db;
}

db()

const DsoMap_t& Ath::DsoDb::db ( ) const

inline

repository of components

Definition at line 94 of file DsoDb.h.

{ return m_db; }

dict_duplicates()

DsoDb::DsoMap_t Ath::DsoDb::dict_duplicates

(

bool

pedantic = false

)

const

table of dict-duplicates: {type: [lib1, lib2, ...]}

Definition at line 509 of file DsoDb.cxx.

{
  DsoMap_t dups;
  get_dups(dups, m_db, pedantic);
  return dups;
}

dso_files()

const std::vector<std::string>& Ath::DsoDb::dso_files ( ) const

inline

list of all dsomap/rootmap files we know about

Definition at line 87 of file DsoDb.h.

  { return m_dsofiles; }

duplicates()

DsoDb::DsoMap_t Ath::DsoDb::duplicates	(	const std::string &	libname,
		bool	pedantic = false
	)		const

list of libraries hosting duplicate reflex-types

Definition at line 474 of file DsoDb.cxx.

{
  DsoMap_t dups;
  const std::string basename_lib = to_string(fs::path(libname).filename());
  std::vector<std::string> caps = this->capabilities(libname);
  const DsoMap_t* dbs[] = { &m_pf, &m_db };
 
  for (std::size_t i = 0, imax = 2; i < imax; ++i) {
    DsoMap_t dup_db;
    this->get_dups(dup_db, *dbs[i], pedantic);
    for (DsoMap_t::const_iterator 
           idb = dup_db.begin(), 
           idbend = dup_db.end();
         idb != idbend;
         ++idb) {
      if (std::find(caps.begin(), caps.end(), idb->first) != caps.end()) {
        for (Libs_t::const_iterator 
               ilib = idb->second.begin(),
               ilibend=idb->second.end();
             ilib != ilibend;
             ++ilib) {
          fs::path p(*ilib);
          const std::string basename = to_string(p.filename());
          if (basename != libname) {
            dups[idb->first].push_back(*ilib);
          }
        }
      }
    }
  }  
  return dups;
}

get_dups()

void Ath::DsoDb::get_dups ( DsoMap_t &  dups, const DsoMap_t &  db, bool  pedantic  ) const

private

get the duplicates for a given repository of components

Definition at line 594 of file DsoDb.cxx.

{
  for (DsoMap_t::const_iterator idb = db.begin(), iend = db.end();
       idb != iend;
       ++idb) {
    if (idb->second.size() == 1) {
      continue;
    }
    Libs_t libs;
    if (pedantic) {
      libs = idb->second;
    } else {
      std::unordered_set<std::string> baselibs;
      for (Libs_t::const_iterator 
             ilib = idb->second.begin(), 
             ilend= idb->second.end();
           ilib != ilend;
           ++ilib)
      {
        fs::path p(*ilib);
        if (! baselibs.emplace (to_string(p.filename())) . second) {
          // String wasn't in the set.
          libs.push_back(*ilib);
        }
      }
    }
    if (libs.size() > 1) {
      dups[idb->first] = std::move(libs);
    }
  }
}

has_type()

bool Ath::DsoDb::has_type

(

const std::string &

type_name

)

const

Definition at line 263 of file DsoDb.cxx.

{
  if (s_cxx_builtins().find(type_name) != s_cxx_builtins().end()) {
    return true;
  }
  const std::string n = ::to_rootmap_name(type_name);
  if ( m_db.find(n) != m_db.end() ||
       m_pf.find(n) != m_pf.end() ) {
    return true;
  }
  return false;
}

instance()

const DsoDb * Ath::DsoDb::instance ( )

static

factory for the DsoDb

Definition at line 237 of file DsoDb.cxx.

{
   static const DsoDb db;
   return &db;
}

libs()

DsoDb::Libs_t Ath::DsoDb::libs

(

bool

detailed = false

)

const

list of all libraries we know about

Parameters

<tt>detailed</tt>

if true, prints the full path to the library

Definition at line 528 of file DsoDb.cxx.

{
  std::set<std::string> libs;
  const DsoMap_t* dbs[] = { &m_pf, &m_db };
 
  for (std::size_t i = 0, imax = 2; i < imax; ++i) {
    const DsoMap_t& db = *dbs[i];
    for (DsoMap_t::const_iterator idb = db.begin(), iend=db.end();
         idb != iend;
         ++idb) {
      for (Libs_t::const_iterator 
             ilib = idb->second.begin(),
             ilibend=idb->second.end();
           ilib != ilibend;
           ++ilib) {
        if (detailed) {
          libs.insert(*ilib);
        } else {
          libs.insert(to_string(fs::path(*ilib).filename()));
        }
      }
    }
  }
  return Libs_t(libs.begin(), libs.end());
}

operator=()

DsoDb& Ath::DsoDb::operator= ( const DsoDb &  rhs )

private

Assignment operator:

pf()

const DsoMap_t& Ath::DsoDb::pf ( ) const

inline

repository of plugin factories

Definition at line 91 of file DsoDb.h.

{ return m_pf; }

pf_duplicates()

DsoDb::DsoMap_t Ath::DsoDb::pf_duplicates

(

bool

pedantic = false

)

const

table of plugin-factories-duplicates: {type: [lib1, lib2, ...]}

Definition at line 518 of file DsoDb.cxx.

{
  DsoMap_t dups;
  get_dups(dups, m_pf, pedantic);
  return dups;
}

py_keys_from()

static std::vector<std::string> Ath::DsoDb::py_keys_from ( const Ath::DsoDb::DsoMap_t &  m )

inlinestatic

Definition at line 43 of file DsoDb.h.

  {
    std::vector<std::string> k;
    k.reserve(m.size());
    for (Ath::DsoDb::DsoMap_t::const_iterator i = m.begin(), e = m.end();
         i != e;
         ++i) {
      k.push_back(i->first);
    }
    return k;
  }

py_vals_from()

static std::vector<std::vector<std::string> > Ath::DsoDb::py_vals_from ( const Ath::DsoDb::DsoMap_t &  m )

inlinestatic

Definition at line 57 of file DsoDb.h.

  {
    std::vector<Libs_t> v;
    v.reserve(m.size());
    for (Ath::DsoDb::DsoMap_t::const_iterator i = m.begin(), e = m.end();
         i != e;
         ++i) {
      v.push_back(i->second);
    }
    return v;
  }

Member Data Documentation

m_db

DsoMap_t Ath::DsoDb::m_db

private

repository of components

Definition at line 153 of file DsoDb.h.

m_dsofiles

std::vector<std::string> Ath::DsoDb::m_dsofiles

private

list of dsofiles

Definition at line 156 of file DsoDb.h.

m_pf

DsoMap_t Ath::DsoDb::m_pf

private

repository of plugin factories

Definition at line 150 of file DsoDb.h.

---

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

• DsoDb.h
• DsoDb.cxx