#include <LibraryManager.h>

Classes
struct	nothrow_t

Public Member Functions
	LibraryManager (cet::search_path search_path, std::string lib_type)

	LibraryManager (cet::search_path search_path, std::string lib_type, std::string pattern)

	LibraryManager (std::string lib_type)

	LibraryManager (std::string lib_type, std::string pattern)

template<typename T >
T	getSymbolByLibspec (std::string const &libspec, std::string const &sym_name) const

template<typename T >
void	getSymbolByLibspec (std::string const &libspec, std::string const &sym_name, T &sym) const

template<typename T >
T	getSymbolByPath (std::string const &lib_loc, std::string const &sym_name) const

template<typename T >
void	getSymbolByPath (std::string const &lib_loc, std::string const &sym_name, T &sym) const

template<typename T >
T	getSymbolByLibspec (std::string const &libspec, std::string const &sym_name, nothrow_t) const

template<typename T >
void	getSymbolByLibspec (std::string const &libspec, std::string const &sym_name, T &sym, nothrow_t) const

template<typename T >
T	getSymbolByPath (std::string const &lib_loc, std::string const &sym_name, nothrow_t) const

template<typename T >
void	getSymbolByPath (std::string const &lib_loc, std::string const &sym_name, T &sym, nothrow_t) const

size_t	getLoadableLibraries (std::vector< std::string > &list) const

template<class OutIter >
size_t	getLoadableLibraries (OutIter dest) const

size_t	getLoadedLibraries (std::vector< std::string > &list) const

template<class OutIter >
size_t	getLoadedLibraries (OutIter dest) const

size_t	getValidLibspecs (std::vector< std::string > &list) const

template<class OutIter >
size_t	getValidLibspecs (OutIter dest) const

std::pair< std::string, std::string >	getSpecsByPath (std::string const &lib_loc) const

void	loadAllLibraries () const

bool	libraryIsLoaded (std::string const &path) const

bool	libraryIsLoadable (std::string const &path) const

std::string	libType () const

std::string	patternStem () const

Static Public Attributes
static struct cet::LibraryManager::nothrow_t	nothrow

Private Types
using	lib_loc_map_t = std::map< std::string, std::string >

using	spec_trans_map_t = std::map< std::string, std::set< std::string >>

using	lib_ptr_map_t = std::map< std::string, void * >

using	good_spec_trans_map_t = std::map< std::string, std::string >

Private Member Functions
void	lib_loc_map_inserter (std::string const &path)

void	spec_trans_map_inserter (lib_loc_map_t::value_type const &entry)

void	good_spec_trans_map_inserter (spec_trans_map_t::value_type const &entry)

void *	get_lib_ptr (std::string const &lib_loc) const

void *	getSymbolByLibspec_ (std::string const &libspec, std::string const &sym_name, bool should_throw_on_dlsym=true) const

void *	getSymbolByPath_ (std::string const &lib_loc, std::string const &sym_name, bool should_throw_on_dlsym=true) const

Static Private Member Functions
static std::string	dllExtPattern ()

Private Attributes
cet::search_path const	search_path_

std::string const	lib_type_

std::string const	pattern_stem_

lib_loc_map_t	lib_loc_map_ {}

spec_trans_map_t	spec_trans_map_ {}

good_spec_trans_map_t	good_spec_trans_map_ {}

lib_ptr_map_t	lib_ptr_map_ {}

Detailed Description

Definition at line 19 of file LibraryManager.h.

Member Typedef Documentation

using cet::LibraryManager::good_spec_trans_map_t = std::map<std::string, std::string>

private

Definition at line 142 of file LibraryManager.h.

using cet::LibraryManager::lib_loc_map_t = std::map<std::string, std::string>

private

Definition at line 139 of file LibraryManager.h.

using cet::LibraryManager::lib_ptr_map_t = std::map<std::string, void*>

private

Definition at line 141 of file LibraryManager.h.

using cet::LibraryManager::spec_trans_map_t = std::map<std::string, std::set<std::string>>

private

Definition at line 140 of file LibraryManager.h.

Constructor & Destructor Documentation

cet::LibraryManager::LibraryManager	(	cet::search_path	search_path,
		std::string	lib_type
	)

explicit

Definition at line 34 of file LibraryManager.cc.

   : LibraryManager{std::move(search_path),
                    std::move(lib_type),
                    default_pattern_stem}
 {}

cet::LibraryManager::LibraryManager	(	cet::search_path	search_path,
		std::string	lib_type,
		std::string	pattern
	)

explicit

Definition at line 41 of file LibraryManager.cc.

   : search_path_{detail::plugin_search_path(std::move(search_path))}
   , lib_type_{std::move(lib_type)}
   , pattern_stem_{std::move(pattern)}
 {
   std::vector<std::string> matches;
   search_path_.find_files(
     shlib_prefix() + pattern_stem_ + lib_type_ + dllExtPattern(), matches);
 
   // Note the use of reverse iterators here: files found earlier in
   // the vector will therefore overwrite those found later, which is
   // what we want from "search path"-type behavior.
   std::for_each(matches.rbegin(), matches.rend(), [this](auto const& match) {
     this->lib_loc_map_inserter(match);
   });
 
   // Build the spec to long library name translation table.
   for (auto const& p : lib_loc_map_) {
     spec_trans_map_inserter(p);
   }
 
   // Build the fast good-translation table.
   for (auto const& p : spec_trans_map_) {
     good_spec_trans_map_inserter(p);
   }
 }

cet::LibraryManager::LibraryManager ( std::string lib_type )

explicit

Definition at line 70 of file LibraryManager.cc.

71 : LibraryManager{std::move(lib_type), default_pattern_stem}

72 {}

cet::LibraryManager::LibraryManager

LibraryManager(cet::search_path search_path, std::string lib_type)

Definition: LibraryManager.cc:34

wirecell.gen.depos.move

def move(depos, offset)

Definition: depos.py:107

cet::LibraryManager::LibraryManager	(	std::string	lib_type,
		std::string	pattern
	)

explicit

Definition at line 74 of file LibraryManager.cc.

   : LibraryManager{search_path{plugin_libpath(), std::nothrow},
                    std::move(lib_type),
                    std::move(pattern)}
 {}

Member Function Documentation

std::string cet::LibraryManager::dllExtPattern ( )

inlinestaticprivate

Definition at line 172 of file LibraryManager.h.

 {
   static std::string const dllExtPatt{"\\" + shlib_suffix()};
   return dllExtPatt;
 }

void * cet::LibraryManager::get_lib_ptr ( std::string const & lib_loc ) const

private

Definition at line 202 of file LibraryManager.cc.

 {
   lib_ptr_map_t::const_iterator const it{lib_ptr_map_.find(lib_loc)};
   if (it == lib_ptr_map_.cend() || it->second == nullptr) {
     dlerror();
     void* ptr = dlopen(lib_loc.c_str(), RTLD_LAZY | RTLD_GLOBAL);
     lib_ptr_map_[lib_loc] = ptr;
     return ptr;
   }
   return it->second;
 }

size_t cet::LibraryManager::getLoadableLibraries ( std::vector< std::string > & list ) const

Definition at line 81 of file LibraryManager.cc.

 {
   return getLoadableLibraries(std::back_inserter(list));
 }

template<class OutIter >

size_t cet::LibraryManager::getLoadableLibraries ( OutIter dest ) const

Definition at line 214 of file LibraryManager.h.

 {
   size_t count{};
   for (auto const& lib_loc : lib_loc_map_) {
     *dest++ = lib_loc.second;
     ++count;
   }
   return count;
 }

size_t cet::LibraryManager::getLoadedLibraries ( std::vector< std::string > & list ) const

Definition at line 87 of file LibraryManager.cc.

 {
   return getLoadedLibraries(std::back_inserter(list));
 }

template<class OutIter >

size_t cet::LibraryManager::getLoadedLibraries ( OutIter dest ) const

Definition at line 265 of file LibraryManager.h.

 {
   size_t count{};
   for (auto const& lib_ptr : lib_ptr_map_) {
     *dest++ = lib_ptr.first;
     ++count;
   }
   return count;
 }

std::pair< std::string, std::string > cet::LibraryManager::getSpecsByPath ( std::string const & lib_loc ) const

Definition at line 99 of file LibraryManager.cc.

 {
   // pair<short_spec,full_spec>
   std::pair<std::string, std::string> result;
   for (auto const& entry : spec_trans_map_) {
     auto const& spec = maybe_trim_shlib_prefix(entry.first);
     auto const& paths = entry.second;
 
     auto const path_iter = paths.find(lib_loc);
     if (path_iter != paths.end()) {
       if (spec.find("/") != std::string::npos)
         result.second = spec;
       else
         result.first = spec;
     }
     if (!result.first.empty() && !result.second.empty())
       break;
   }
 
   return result;
 }

template<typename T >

T cet::LibraryManager::getSymbolByLibspec	(	std::string const &	libspec,
		std::string const &	sym_name
	)		const

inline

Definition at line 180 of file LibraryManager.h.

 {
   return hard_cast<T>(getSymbolByLibspec_(libspec, sym_name));
 }

template<typename T >

void cet::LibraryManager::getSymbolByLibspec	(	std::string const &	libspec,
		std::string const &	sym_name,
		T &	sym
	)		const

inline

Definition at line 188 of file LibraryManager.h.

 {
   hard_cast<T>(getSymbolByLibspec_(libspec, sym_name), sym);
 }

template<typename T >

T cet::LibraryManager::getSymbolByLibspec	(	std::string const &	libspec,
		std::string const &	sym_name,
		nothrow_t
	)		const

inline

Definition at line 227 of file LibraryManager.h.

 {
   return hard_cast<T>(getSymbolByLibspec_(libspec, sym_name, false));
 }

template<typename T >

void cet::LibraryManager::getSymbolByLibspec	(	std::string const &	libspec,
		std::string const &	sym_name,
		T &	sym,
		nothrow_t
	)		const

inline

Definition at line 236 of file LibraryManager.h.

 {
   hard_cast<T>(getSymbolByLibspec_(libspec, sym_name, false), sym);
 }

void * cet::LibraryManager::getSymbolByLibspec_	(	std::string const &	libspec,
		std::string const &	sym_name,
		bool	should_throw_on_dlsym = `true`
	)		const

private

Definition at line 215 of file LibraryManager.cc.

 {
   if (libspec.find("_") != std::string::npos) {
     // Plugin names (and hence the class name) cannot contain an underscore.
     throw exception("LogicError", "IllegalUnderscore.")
       << "Library specification \"" << libspec
       << "\" contains an illegal underscore.\n"
       << "The class name and path to it may not contain an underscore. "
       << "If this is a configuration error, plase correct it; "
       << "if the module's class name or its location within its "
       << "enclosing package really do have an underscore this situation "
       << "must be rectified.\n";
   }
   auto const trans = good_spec_trans_map_.find(libspec);
   if (trans == good_spec_trans_map_.cend()) {
     // No good translation => zero or too many
     std::ostringstream error_msg;
     error_msg << "Library specification \"" << libspec << "\"";
     auto const bad_trans = spec_trans_map_.find(libspec);
     if (bad_trans != spec_trans_map_.cend()) {
       error_msg << " corresponds to multiple libraries:\n";
       copy_all(bad_trans->second,
                std::ostream_iterator<std::string>(error_msg, "\n"));
     } else {
       auto const& path_name = search_path_.showenv();
       error_msg << " does not correspond to any library";
       if (!path_name.empty()) {
         error_msg << " in " << path_name;
       }
       error_msg << " of type \"" << lib_type_ << "\"\n";
     }
     throw exception("Configuration") << error_msg.str();
   }
   return getSymbolByPath_(trans->second, sym_name, should_throw_on_dlsym);
 }

template<typename T >

T cet::LibraryManager::getSymbolByPath	(	std::string const &	lib_loc,
		std::string const &	sym_name
	)		const

inline

Definition at line 197 of file LibraryManager.h.

 {
   return hard_cast<T>(getSymbolByPath_(lib_loc, sym_name));
 }

template<typename T >

void cet::LibraryManager::getSymbolByPath	(	std::string const &	lib_loc,
		std::string const &	sym_name,
		T &	sym
	)		const

inline

Definition at line 205 of file LibraryManager.h.

 {
   hard_cast<T>(getSymbolByPath_(lib_loc, sym_name), sym);
 }

template<typename T >

T cet::LibraryManager::getSymbolByPath	(	std::string const &	lib_loc,
		std::string const &	sym_name,
		nothrow_t
	)		const

inline

Definition at line 246 of file LibraryManager.h.

 {
   return hard_cast<T>(getSymbolByPath_(lib_loc, sym_name, false));
 }

template<typename T >

void cet::LibraryManager::getSymbolByPath	(	std::string const &	lib_loc,
		std::string const &	sym_name,
		T &	sym,
		nothrow_t
	)		const

inline

Definition at line 255 of file LibraryManager.h.

 {
   hard_cast<T>(getSymbolByPath_(lib_loc, sym_name, false), sym);
 }

void * cet::LibraryManager::getSymbolByPath_	(	std::string const &	lib_loc,
		std::string const &	sym_name,
		bool	should_throw_on_dlsym = `true`
	)		const

private

Definition at line 254 of file LibraryManager.cc.

 {
   void* result = nullptr;
   void* lib_ptr = get_lib_ptr(lib_loc);
   if (lib_ptr == nullptr) {
     throw exception("Configuration")
       << "Unable to load requested library " << lib_loc << "\n"
       << demangle_message(dlerror()) << "\n";
   } else { // Found library
     dlerror();
     result = dlsym(lib_ptr, sym_name.c_str());
     char const* error = dlerror();
     if (error != nullptr) { // Error message
       result = nullptr;
       if (should_throw_on_dlsym) {
         throw exception("Configuration")
           << "Unable to load requested symbol " << demangle_symbol(sym_name)
           << " from library " << lib_loc << "\n"
           << demangle_message(error) << "\n";
       }
     }
   }
   return result;
 }

size_t cet::LibraryManager::getValidLibspecs ( std::vector< std::string > & list ) const

Definition at line 93 of file LibraryManager.cc.

 {
   return getValidLibspecs(std::back_inserter(list));
 }

template<class OutIter >

size_t cet::LibraryManager::getValidLibspecs ( OutIter dest ) const

Definition at line 277 of file LibraryManager.h.

 {
   size_t count{};
   for (auto const& spec_trans : spec_trans_map_) {
     *dest++ = spec_trans.first;
     ++count;
   }
   return count;
 }

void cet::LibraryManager::good_spec_trans_map_inserter ( spec_trans_map_t::value_type const & entry )

private

Definition at line 193 of file LibraryManager.cc.

 {
   if (entry.second.size() == 1) {
     good_spec_trans_map_[entry.first] = *(entry.second.begin());
   }
 }

void cet::LibraryManager::lib_loc_map_inserter ( std::string const & path )

private

Definition at line 153 of file LibraryManager.cc.

 {
   lib_loc_map_[boost::filesystem::path(path).filename().native()] = path;
 }

bool cet::LibraryManager::libraryIsLoadable ( std::string const & path ) const

Definition at line 140 of file LibraryManager.cc.

 {
   // TODO: If called with any frequency, this should be made more
   // efficient.
   for (auto const& lib : lib_loc_map_) {
     if (path == lib.second) {
       return true;
     }
   }
   return false;
 }

bool cet::LibraryManager::libraryIsLoaded ( std::string const & path ) const

Definition at line 134 of file LibraryManager.cc.

 {
   return lib_ptr_map_.find(path) != lib_ptr_map_.end();
 }

std::string cet::LibraryManager::libType ( ) const

inline

Definition at line 125 of file LibraryManager.h.

   {
     return lib_type_;
   }

void cet::LibraryManager::loadAllLibraries ( ) const

Definition at line 122 of file LibraryManager.cc.

 {
   for (auto const& lib : lib_loc_map_) {
     if (get_lib_ptr(lib.second) == nullptr) {
       throw exception("Configuration")
         << "Unable to load requested library " << lib.second << "\n"
         << demangle_message(dlerror()) << "\n";
     }
   }
 }

std::string cet::LibraryManager::patternStem ( ) const

inline

Definition at line 132 of file LibraryManager.h.

   {
     return pattern_stem_;
   }

void cet::LibraryManager::spec_trans_map_inserter ( lib_loc_map_t::value_type const & entry )

private

Definition at line 159 of file LibraryManager.cc.

 {
   // First obtain short spec.
   boost::regex const e{"([^_]+)_" + lib_type_ + dllExtPattern() + '$'};
   boost::match_results<std::string::const_iterator> match_results;
   if (boost::regex_search(entry.first, match_results, e)) {
     spec_trans_map_[match_results[1]].insert(entry.second);
   } else {
     throw exception("LogicError")
       << "Internal error in spec_trans_map_inserter for entry " << entry.first
       << " with pattern " << e.str();
   }
   // Next, convert library filename to full libspec.
   std::ostringstream lib_name;
   std::ostream_iterator<char, char> oi{lib_name};
   boost::regex_replace(oi,
                        entry.first.begin(),
                        entry.first.end(),
                        boost::regex{"(_+)"},
                        std::string{"(?1/)"},
                        boost::match_default | boost::format_all);
   boost::regex const stripper{"^lib(.*)/" + lib_type_ + "\\..*$"};
   std::string const lib_name_str{lib_name.str()};
   if (boost::regex_search(lib_name_str, match_results, stripper)) {
     spec_trans_map_[match_results[1]].insert(entry.second);
   } else {
     throw exception("LogicError")
       << "Internal error in spec_trans_map_inserter stripping "
       << lib_name.str();
   }
 }

Member Data Documentation

good_spec_trans_map_t cet::LibraryManager::good_spec_trans_map_ {}

private

Definition at line 166 of file LibraryManager.h.

lib_loc_map_t cet::LibraryManager::lib_loc_map_ {}

private

Definition at line 162 of file LibraryManager.h.

lib_ptr_map_t cet::LibraryManager::lib_ptr_map_ {}

mutableprivate

Definition at line 168 of file LibraryManager.h.

std::string const cet::LibraryManager::lib_type_

private

Definition at line 159 of file LibraryManager.h.

struct cet::LibraryManager::nothrow_t cet::LibraryManager::nothrow

static

std::string const cet::LibraryManager::pattern_stem_

private

Definition at line 160 of file LibraryManager.h.

cet::search_path const cet::LibraryManager::search_path_

private

Definition at line 158 of file LibraryManager.h.

spec_trans_map_t cet::LibraryManager::spec_trans_map_ {}

private

Definition at line 164 of file LibraryManager.h.

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

cetlib/cetlib/LibraryManager.h
cetlib/cetlib/LibraryManager.cc

Classes

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation