eonc::MetatomicLoader Class Reference

#include <MetatomicLoader.h>

Inheritance diagram for eonc::MetatomicLoader:

Public Member Functions
bool	try_load ()
	Attempt (re)load if not yet successful. Safe after potentials_path inject.
bool	is_loaded () const noexcept override
void	require_loaded () override
	Load on first use, then throw if libmetatomic_pot is not available.
	~MetatomicLoader () override
	MetatomicLoader (const MetatomicLoader &)=delete
MetatomicLoader &	operator= (const MetatomicLoader &)=delete
Public Member Functions inherited from eonc::IMetatomicLoader
virtual	~IMetatomicLoader ()=default
	IMetatomicLoader (const IMetatomicLoader &)=delete
IMetatomicLoader &	operator= (const IMetatomicLoader &)=delete

Static Public Member Functions
static MetatomicLoader &	instance ()
	Thread-safe singleton accessor (Meyer's pattern). Does not dlopen.

Private Member Functions
	MetatomicLoader ()=default

Private Attributes
bool	m_loaded {false}
dynlib::Handle	m_handle {}

Friends
class	Runtime

Additional Inherited Members
Public Types inherited from eonc::IMetatomicLoader
using	create_fn = EonMtaPot *(*)(const EonMtaConfig *, char *, size_t)
using	destroy_fn = void (*)(EonMtaPot *)
using	force_fn
using	abi_version_fn = int (*)(void)
Public Attributes inherited from eonc::IMetatomicLoader
create_fn	create {nullptr}
destroy_fn	destroy {nullptr}
force_fn	force {nullptr}
abi_version_fn	abi_version {nullptr}
Protected Member Functions inherited from eonc::IMetatomicLoader
	IMetatomicLoader ()=default

Detailed Description

Definition at line 49 of file MetatomicLoader.h.

Constructor & Destructor Documentation

~MetatomicLoader()

eonc::MetatomicLoader::~MetatomicLoader ( )

override

Definition at line 106 of file MetatomicLoader.cpp.

{ dynlib::close(m_handle); }

MetatomicLoader() [1/2]

eonc::MetatomicLoader::MetatomicLoader ( const MetatomicLoader & )

delete

MetatomicLoader() [2/2]

eonc::MetatomicLoader::MetatomicLoader ( )

privatedefault

Member Function Documentation

instance()

MetatomicLoader & eonc::MetatomicLoader::instance ( )

static

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

Definition at line 19 of file MetatomicLoader.cpp.

                                           {
  static MetatomicLoader loader;
  return loader;
}

is_loaded()

bool eonc::MetatomicLoader::is_loaded ( ) const

inlinenodiscardoverridevirtualnoexcept

Implements eonc::IMetatomicLoader.

Definition at line 57 of file MetatomicLoader.h.

{ return m_loaded; }

operator=()

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

delete

require_loaded()

void eonc::MetatomicLoader::require_loaded ( )

overridevirtual

Load on first use, then throw if libmetatomic_pot is not available.

Implements eonc::IMetatomicLoader.

Definition at line 108 of file MetatomicLoader.cpp.

                                     {
  if (!try_load()) {
    throw std::runtime_error(
        "Metatomic potential requested but libmetatomic_pot.so not found or "
        "ABI mismatch.\n"
        "Build with -Dwith_metatomic=true and put the plugin on "
        "LD_LIBRARY_PATH / EON_POTENTIALS_PATH / [Potential] potentials_path.");
  }
}

try_load()

bool eonc::MetatomicLoader::try_load

(

)

Attempt (re)load if not yet successful. Safe after potentials_path inject.

Definition at line 24 of file MetatomicLoader.cpp.

                               {
  if (m_loaded)
    return true;
 
#ifdef _WIN32
  const char *candidates[] = {"metatomic_pot.dll", "libmetatomic_pot.dll",
                              nullptr};
#elif defined(__APPLE__)
  const char *candidates[] = {"libmetatomic_pot.dylib", "libmetatomic_pot.so",
                              nullptr};
#else
  const char *candidates[] = {"libmetatomic_pot.so", nullptr};
#endif
 
  // RTLD_GLOBAL without DEEPBIND so MetatomicPotential's Potential/PotRegistry
  // symbols bind to the already-loaded host libeonclib (single registry).
  auto open_mta = [](const char *name) -> dynlib::Handle {
#if defined(__linux__)
    return ::dlopen(name, RTLD_NOW | RTLD_GLOBAL);
#elif defined(_WIN32)
    return dynlib::open(name);
#else
    return ::dlopen(name, RTLD_NOW | RTLD_GLOBAL);
#endif
  };
 
  for (const char **p = candidates; *p; ++p) {
    m_handle = open_mta(*p);
    if (m_handle)
      break;
  }
  if (!m_handle) {
    for (const auto &dir : PluginLoader::instance().search_paths()) {
      for (const char **p = candidates; *p; ++p) {
        std::string full = dir;
        if (!full.empty() && full.back() != '/' && full.back() != '\\')
          full += '/';
        full += *p;
        m_handle = open_mta(full.c_str());
        if (m_handle)
          break;
      }
      if (m_handle)
        break;
    }
  }
  if (!m_handle)
    return false;
 
  create = dynlib::loadSym<create_fn>(m_handle, "eon_mta_pot_create");
  destroy = dynlib::loadSym<destroy_fn>(m_handle, "eon_mta_pot_destroy");
  force = dynlib::loadSym<force_fn>(m_handle, "eon_mta_pot_force");
  abi_version =
      dynlib::loadSym<abi_version_fn>(m_handle, "eon_mta_abi_version");
 
  if (!create || !destroy || !force || !abi_version) {
    std::cerr << "[Metatomic] libmetatomic_pot loaded but missing C ABI "
                 "symbols\n";
    dynlib::close(m_handle);
    m_handle = {};
    create = nullptr;
    destroy = nullptr;
    force = nullptr;
    abi_version = nullptr;
    return false;
  }
  const int ver = abi_version();
  if (ver != EON_MTA_ABI_VERSION) {
    std::cerr << "[Metatomic] ABI version mismatch: library=" << ver
              << " host=" << EON_MTA_ABI_VERSION << "\n";
    dynlib::close(m_handle);
    m_handle = {};
    create = nullptr;
    destroy = nullptr;
    force = nullptr;
    abi_version = nullptr;
    return false;
  }
  m_loaded = true;
  return true;
}

Friends And Related Symbol Documentation

Runtime

friend class Runtime

friend

Definition at line 68 of file MetatomicLoader.h.

Member Data Documentation

m_handle

dynlib::Handle eonc::MetatomicLoader::m_handle {}

private

Definition at line 71 of file MetatomicLoader.h.

{};

m_loaded

bool eonc::MetatomicLoader::m_loaded {false}

private

Definition at line 70 of file MetatomicLoader.h.

{false};

---

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

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