eonc::PluginLoader Class Reference

#include <PluginLoader.h>

Public Member Functions
void	add_config_paths (const std::string &colon_paths)
	Inject search paths from the eOn config file.
template<typename Fn>
Fn	load_sym (const char *lib_base, const char *sym_name)
	Load a symbol from a named potential library.
void	throw_not_found (const char *lib_base, const char *description) const
	Throw a descriptive error for a missing potential library.
bool	lib_present (const char *lib_base) const
	Filesystem probe: a matching library file is on the configured search path.
const std::vector< std::string > &	search_paths () const noexcept
	Get the current search paths (for diagnostics).
	PluginLoader (const PluginLoader &)=delete
PluginLoader &	operator= (const PluginLoader &)=delete

Static Public Member Functions
static PluginLoader &	instance ()
	Thread-safe singleton accessor (Meyer's pattern).

Private Member Functions
	PluginLoader ()
	~PluginLoader ()
dynlib::Handle	open_lib (const char *lib_base)
std::vector< std::string >	lib_names (const char *lib_base) const
void	append_paths (const std::string &path_str, char sep)

Private Attributes
std::vector< std::string >	m_search_paths
std::mutex	m_mutex
std::unordered_map< std::string, dynlib::Handle >	m_handles
std::string	m_last_load_error
	Last dynlib::error() from a failed open (for throw_not_found).
bool	m_last_load_saw_file = false

Detailed Description

Definition at line 41 of file PluginLoader.h.

Constructor & Destructor Documentation

PluginLoader() [1/2]

eonc::PluginLoader::PluginLoader ( const PluginLoader & )

delete

PluginLoader() [2/2]

eonc::PluginLoader::PluginLoader ( )

private

Definition at line 25 of file PluginLoader.cpp.

                           {
  // Seed from EON_POTENTIALS_PATH env var (colon-separated on POSIX).
  // Config-file paths are prepended later via add_config_paths().
  const char *env = std::getenv("EON_POTENTIALS_PATH");
  if (env && *env) {
#ifdef _WIN32
    append_paths(env, ';');
#else
    append_paths(env, ':');
#endif
  }
}

~PluginLoader()

eonc::PluginLoader::~PluginLoader ( )

private

Definition at line 38 of file PluginLoader.cpp.

                            {
  for (auto &[name, handle] : m_handles) {
    dynlib::close(handle);
  }
}

Member Function Documentation

add_config_paths()

void eonc::PluginLoader::add_config_paths

(

const std::string &

colon_paths

)

Inject search paths from the eOn config file.

Parameters

colon_paths

colon-separated directory list (may be empty) These paths are inserted before the EON_POTENTIALS_PATH paths.

Definition at line 66 of file PluginLoader.cpp.

                                                                {
  if (colon_paths.empty())
    return;
  std::lock_guard<std::mutex> lock(m_mutex);
  // Config paths have higher priority than env-var paths: insert at front.
  std::vector<std::string> new_paths;
#ifdef _WIN32
  const char sep = ';';
#else
  const char sep = ':';
#endif
  std::string::size_type start = 0;
  while (start < colon_paths.size()) {
    auto pos = colon_paths.find(sep, start);
    if (pos == std::string::npos)
      pos = colon_paths.size();
    if (pos > start) {
      std::string p = colon_paths.substr(start, pos - start);
      bool dup = false;
      for (const auto &existing : m_search_paths) {
        if (existing == p) {
          dup = true;
          break;
        }
      }
      if (!dup)
        new_paths.push_back(std::move(p));
    }
    start = pos + 1;
  }
  m_search_paths.insert(m_search_paths.begin(), new_paths.begin(),
                        new_paths.end());
}

append_paths()

void eonc::PluginLoader::append_paths ( const std::string & path_str, char sep )

private

Definition at line 44 of file PluginLoader.cpp.

                                                                   {
  std::string::size_type start = 0;
  while (start < path_str.size()) {
    auto pos = path_str.find(sep, start);
    if (pos == std::string::npos)
      pos = path_str.size();
    if (pos > start) {
      std::string p = path_str.substr(start, pos - start);
      bool dup = false;
      for (const auto &existing : m_search_paths) {
        if (existing == p) {
          dup = true;
          break;
        }
      }
      if (!dup)
        m_search_paths.push_back(std::move(p));
    }
    start = pos + 1;
  }
}

instance()

PluginLoader & eonc::PluginLoader::instance ( )

static

Thread-safe singleton accessor (Meyer's pattern).

Definition at line 20 of file PluginLoader.cpp.

                                     {
  static PluginLoader loader;
  return loader;
}

lib_names()

std::vector< std::string > eonc::PluginLoader::lib_names ( const char * lib_base ) const

private

Definition at line 100 of file PluginLoader.cpp.

                                                                       {
  std::vector<std::string> names;
#ifdef _WIN32
  names.push_back(std::string(lib_base) + ".dll");
  names.push_back(std::string("lib") + lib_base + ".dll");
#elif defined(__APPLE__)
  names.push_back(std::string("lib") + lib_base + ".dylib");
#else
  names.push_back(std::string("lib") + lib_base + ".so");
#endif
  return names;
}

lib_present()

bool eonc::PluginLoader::lib_present ( const char * lib_base ) const

nodiscard

Filesystem probe: a matching library file is on the configured search path.

Does not dlopen, so plugin static initializers (banners) do not run.

Definition at line 164 of file PluginLoader.cpp.

                                                         {
  std::lock_guard<std::mutex> lock(m_mutex);
  auto names = lib_names(lib_base);
  for (const auto &dir : m_search_paths) {
    for (const auto &name : names) {
      std::error_code ec;
      if (std::filesystem::exists(std::filesystem::path(dir) / name, ec))
        return true;
    }
  }
  return false;
}

load_sym()

template<typename Fn>

Fn eonc::PluginLoader::load_sym ( const char * lib_base, const char * sym_name )

inline

Load a symbol from a named potential library.

Parameters

lib_base	Base name without platform prefix/suffix (e.g. "eon_sw")
sym_name	Symbol to load (e.g. "sw_")

Returns

Function pointer, or nullptr if not found.

Definition at line 56 of file PluginLoader.h.

                                                          {
    dynlib::Handle h = open_lib(lib_base);
    if (!h)
      return nullptr;
    return dynlib::loadSym<Fn>(h, sym_name);
  }

open_lib()

dynlib::Handle eonc::PluginLoader::open_lib ( const char * lib_base )

private

Definition at line 113 of file PluginLoader.cpp.

                                                        {
  std::lock_guard<std::mutex> lock(m_mutex);
 
  auto it = m_handles.find(lib_base);
  if (it != m_handles.end()) {
    return it->second;
  }
 
  auto names = lib_names(lib_base);
  dynlib::Handle h{};
  std::string last_err;
  bool any_file = false;
 
  // Probe the filesystem first. dlopen of a present plugin runs that
  // library's static initializers (Fortran / LAMMPS banners), so skip
  // names that are not on disk.
  for (const auto &dir : m_search_paths) {
    for (const auto &name : names) {
      std::string full = (std::filesystem::path(dir) / name).string();
      std::error_code ec;
      if (!std::filesystem::exists(full, ec))
        continue;
      any_file = true;
      h = dynlib::open(full.c_str());
      if (h) {
        m_handles[lib_base] = h;
        return h;
      }
      // Capture immediately after LoadLibrary/dlopen (GetLastError/dlerror).
      last_err = dynlib::error();
    }
  }
 
  // Fall back to system search (LD_LIBRARY_PATH, etc.)
  for (const auto &name : names) {
    h = dynlib::open(name.c_str());
    if (h) {
      m_handles[lib_base] = h;
      return h;
    }
    last_err = dynlib::error();
  }
 
  // Stash diagnostics for throw_not_found (thread-local; open is
  // mutex-guarded).
  m_last_load_error = last_err;
  m_last_load_saw_file = any_file;
  m_handles[lib_base] = nullptr;
  return nullptr;
}

operator=()

PluginLoader & eonc::PluginLoader::operator= ( const PluginLoader & )

delete

search_paths()

const std::vector< std::string > & eonc::PluginLoader::search_paths ( ) const

inlinenodiscardnoexcept

Get the current search paths (for diagnostics).

Definition at line 73 of file PluginLoader.h.

                                                                          {
    return m_search_paths;
  }

throw_not_found()

void eonc::PluginLoader::throw_not_found	(	const char *	lib_base,
		const char *	description ) const

Throw a descriptive error for a missing potential library.

Definition at line 177 of file PluginLoader.cpp.

                                                                  {
  auto names = lib_names(lib_base);
  std::ostringstream oss;
  oss << description << " requested but library not found.\n"
      << "Looked for: ";
  for (size_t i = 0; i < names.size(); ++i) {
    if (i > 0)
      oss << ", ";
    oss << names[i];
  }
  oss << "\n";
  if (!m_search_paths.empty()) {
    oss << "Search paths (config potentials_path + EON_POTENTIALS_PATH):\n";
    for (const auto &p : m_search_paths) {
      oss << "  " << p << "\n";
    }
  }
  if (m_last_load_saw_file) {
    oss << "A matching file was present but LoadLibrary/dlopen failed";
    if (!m_last_load_error.empty())
      oss << ": " << m_last_load_error;
    oss << "\n(often a missing flang_rt / FortranRuntime dependency on "
           "PATH).\n";
  } else if (!m_last_load_error.empty()) {
    oss << "Loader error: " << m_last_load_error << "\n";
  }
  oss << "Set [Potential] potentials_path in config.ini, "
         "or set EON_POTENTIALS_PATH,\n"
         "or ensure the libraries are in LD_LIBRARY_PATH.";
  throw std::runtime_error(oss.str());
}

Member Data Documentation

m_handles

std::unordered_map<std::string, dynlib::Handle> eonc::PluginLoader::m_handles

private

Definition at line 90 of file PluginLoader.h.

m_last_load_error

std::string eonc::PluginLoader::m_last_load_error

private

Last dynlib::error() from a failed open (for throw_not_found).

Definition at line 92 of file PluginLoader.h.

m_last_load_saw_file

bool eonc::PluginLoader::m_last_load_saw_file = false

private

Definition at line 93 of file PluginLoader.h.

m_mutex

std::mutex eonc::PluginLoader::m_mutex

mutableprivate

Definition at line 89 of file PluginLoader.h.

m_search_paths

std::vector<std::string> eonc::PluginLoader::m_search_paths

private

Definition at line 88 of file PluginLoader.h.

---

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

• /home/runner/work/eOn/eOn/include/eon/potentials/PluginLoader.h
• /home/runner/work/eOn/eOn/client/potentials/PluginLoader.cpp