eonc::MetatomicLoader Class Reference

#include <MetatomicLoader.h>

Public Types
using	create_fn = EonMtaPot *(*)(const EonMtaConfig *, char *, size_t)
using	destroy_fn = void (*)(EonMtaPot *)
using	force_fn
using	abi_version_fn = int (*)(void)

Public Member Functions
bool	try_load ()
	Attempt (re)load if not yet successful. Safe after potentials_path inject.
bool	is_loaded () const noexcept
void	require_loaded ()
	MetatomicLoader (const MetatomicLoader &)=delete
MetatomicLoader &	operator= (const MetatomicLoader &)=delete

Static Public Member Functions
static MetatomicLoader &	instance ()

Public Attributes
create_fn	create {nullptr}
destroy_fn	destroy {nullptr}
force_fn	force {nullptr}
abi_version_fn	abi_version {nullptr}

Private Member Functions
	MetatomicLoader ()=default
	~MetatomicLoader ()

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

Detailed Description

Definition at line 18 of file MetatomicLoader.h.

Member Typedef Documentation

abi_version_fn

using eonc::MetatomicLoader::abi_version_fn = int (*)(void)

Definition at line 24 of file MetatomicLoader.h.

create_fn

using eonc::MetatomicLoader::create_fn = EonMtaPot *(*)(const EonMtaConfig *, char *, size_t)

Definition at line 20 of file MetatomicLoader.h.

destroy_fn

using eonc::MetatomicLoader::destroy_fn = void (*)(EonMtaPot *)

Definition at line 21 of file MetatomicLoader.h.

force_fn

using eonc::MetatomicLoader::force_fn

Initial value:

int (*)(EonMtaPot *, long, const double *, const int *,
                          double *, double *, double *, const double *)

Definition at line 22 of file MetatomicLoader.h.

Constructor & Destructor Documentation

MetatomicLoader() [1/2]

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

delete

MetatomicLoader() [2/2]

eonc::MetatomicLoader::MetatomicLoader ( )

privatedefault

~MetatomicLoader()

eonc::MetatomicLoader::~MetatomicLoader ( )

private

Definition at line 106 of file MetatomicLoader.cpp.

{ dynlib::close(m_handle); }

Member Function Documentation

instance()

MetatomicLoader & eonc::MetatomicLoader::instance ( )

static

Definition at line 19 of file MetatomicLoader.cpp.

                                           {
  static MetatomicLoader loader;
  return loader;
}

is_loaded()

bool eonc::MetatomicLoader::is_loaded ( ) const

inlinenodiscardnoexcept

Definition at line 31 of file MetatomicLoader.h.

{ return m_loaded; }

operator=()

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

delete

require_loaded()

void eonc::MetatomicLoader::require_loaded

(

)

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;
}

Member Data Documentation

abi_version

abi_version_fn eonc::MetatomicLoader::abi_version {nullptr}

Definition at line 37 of file MetatomicLoader.h.

{nullptr};

create

create_fn eonc::MetatomicLoader::create {nullptr}

Definition at line 34 of file MetatomicLoader.h.

{nullptr};

destroy

destroy_fn eonc::MetatomicLoader::destroy {nullptr}

Definition at line 35 of file MetatomicLoader.h.

{nullptr};

force

force_fn eonc::MetatomicLoader::force {nullptr}

Definition at line 36 of file MetatomicLoader.h.

{nullptr};

m_handle

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

private

Definition at line 47 of file MetatomicLoader.h.

{};

m_loaded

bool eonc::MetatomicLoader::m_loaded {false}

private

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