ARTnResource.h

Go to the documentation of this file.

/*
 * This file is part of eOn.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (c) 2010--present, eOn Development Team
 * All rights reserved.
 *
 * Repo:
 * https://github.com/TheochemUI/eOn
 */
 
#pragma once

 
#include "eon/DynLib.h"
#include <mutex>
#include <stdexcept>
#include <string>
 
namespace eonc {
 
// ---------------------------------------------------------------------------
// IARTnResource: injectable ABI. Production uses ARTnResource::instance().
// ---------------------------------------------------------------------------
class IARTnResource {
public:
  // ARTn C API function pointer types (from artn.h)
  using artn_create_fn = int (*)();
  using setup_artn_fn = void (*)(const int nat, bool *cerr);
  using artn_fn = void (*)(const int nat, const double *etot, const double *f,
                           int const *ityp, double *const tau, const int *order,
                           const double *lat, const int *if_pos, int *disp_code,
                           double *disp_vec, bool *lconv);
  using artn_destroy_fn = void (*)();
  using set_param_fn = int (*)(const char *const name, const int crank,
                               const int *csize, const void *cval);
  using get_param_fn = int (*)(const char *name, void **cval);
  using get_runparam_fn = int (*)(const char *name, void **cval);
  using get_data_fn = int (*)(const char *name, void **cval);
  using print_caller_fn = void (*)();
  using artn_step_fn = void (*)(const int nat, const double etot,
                                double *const force, int const *ityp,
                                double *const pos, const double *box,
                                const int *if_pos, double *displ_vec,
                                bool *lconv);
  using get_error_fn = int (*)(void **cmsg);

  std::mutex library_mutex;
 
  virtual ~IARTnResource() = default;
  virtual void require_loaded() = 0;
  [[nodiscard]] virtual bool is_loaded() const noexcept = 0;
  [[nodiscard]] virtual artn_create_fn get_create_fn() const = 0;
  [[nodiscard]] virtual setup_artn_fn get_setup_fn() const = 0;
  [[nodiscard]] virtual artn_fn get_artn_fn() const = 0;
  [[nodiscard]] virtual artn_destroy_fn get_destroy_fn() const = 0;
  [[nodiscard]] virtual set_param_fn get_set_param_fn() const = 0;
  [[nodiscard]] virtual get_param_fn get_get_param_fn() const = 0;
  [[nodiscard]] virtual get_runparam_fn get_get_runparam_fn() const = 0;
  [[nodiscard]] virtual get_data_fn get_get_data_fn() const = 0;
  [[nodiscard]] virtual print_caller_fn get_print_caller_fn() const = 0;
  [[nodiscard]] virtual artn_step_fn get_artn_step_fn() const = 0;
  [[nodiscard]] virtual get_error_fn get_get_error_fn() const = 0;
 
  IARTnResource(const IARTnResource &) = delete;
  IARTnResource &operator=(const IARTnResource &) = delete;
 
protected:
  IARTnResource() = default;
};
 
// ---------------------------------------------------------------------------
// ARTnResource: process-default loader (Meyer's singleton).
// ---------------------------------------------------------------------------
class ARTnResource : public IARTnResource {
public:
  static ARTnResource &instance();
 
  [[nodiscard]] bool is_loaded() const noexcept override { return m_loaded; }

  void require_loaded() override;
 
  [[nodiscard]] artn_create_fn get_create_fn() const override {
    return artn_create_;
  }
  [[nodiscard]] setup_artn_fn get_setup_fn() const override {
    return setup_artn_;
  }
  [[nodiscard]] artn_fn get_artn_fn() const override { return artn_; }
  [[nodiscard]] artn_destroy_fn get_destroy_fn() const override {
    return artn_destroy_;
  }
  [[nodiscard]] set_param_fn get_set_param_fn() const override {
    return set_param_;
  }
  [[nodiscard]] get_param_fn get_get_param_fn() const override {
    return get_param_;
  }
  [[nodiscard]] get_runparam_fn get_get_runparam_fn() const override {
    return get_runparam_;
  }
  [[nodiscard]] get_data_fn get_get_data_fn() const override {
    return get_data_;
  }
  [[nodiscard]] print_caller_fn get_print_caller_fn() const override {
    return print_caller_;
  }
  [[nodiscard]] artn_step_fn get_artn_step_fn() const override {
    return artn_step_;
  }
  [[nodiscard]] get_error_fn get_get_error_fn() const override {
    return get_error_;
  }
 
  ~ARTnResource() override;
  ARTnResource(const ARTnResource &) = delete;
  ARTnResource &operator=(const ARTnResource &) = delete;
 
private:
  ARTnResource();
  friend class Runtime;
 
  bool m_loaded{false};
  dynlib::Handle m_handle{};
 
  // Loaded function pointers (null if library not found)
  artn_create_fn artn_create_{nullptr};
  setup_artn_fn setup_artn_{nullptr};
  artn_fn artn_{nullptr};
  artn_destroy_fn artn_destroy_{nullptr};
  set_param_fn set_param_{nullptr};
  get_param_fn get_param_{nullptr};
  get_runparam_fn get_runparam_{nullptr};
  get_data_fn get_data_{nullptr};
  print_caller_fn print_caller_{nullptr};
  artn_step_fn artn_step_{nullptr};
  get_error_fn get_error_{nullptr};

  template <typename Fn> Fn load_sym(const char *name) const {
    return reinterpret_cast<Fn>(dynlib::sym(m_handle, name));
  }
};

inline ARTnResource &get_artn_resource() { return ARTnResource::instance(); }
 
} // namespace eonc