api.hpp

#ifndef __BIOMC_API_HPP__
#define __BIOMC_API_HPP__
 
#include <api/results.hpp>
#include <common/execinfo.hpp>
#include <common/logger.hpp>
#include <core/case_data.hpp>
#include <core/scalar_factory.hpp>
#include <core/simulation_parameters.hpp>
#include <cstdlib>
#include <initializer_list>
#include <memory>
#include <mixture/species_descriptor.hpp>
#include <optional>
#include <ranges>
#include <simulation/feed_descriptor.hpp>
#include <simulation/mass_transfer.hpp>
#include <string_view>
#include <utility>

namespace Api
{
  constexpr std::array<int, 3>
  get_version()
  {
    return { _BIOMC_VERSION_MAJOR, _BIOMC_VERSION_MINOR, _BIOMC_VERSION_DEV };
  }
 
  // concat 3*two bits
  constexpr int
  validate_version(int major, int minor, int dev)
  {
    auto cmp2 = [](int a, int b) -> int { return 1 + (a > b) - (a < b); };
 
    return (cmp2(major, _BIOMC_VERSION_MAJOR) << 4)
           | (cmp2(minor, _BIOMC_VERSION_MINOR) << 2)
           | (cmp2(dev, _BIOMC_VERSION_DEV) << 0);
  }
 
  constexpr bool
  version_is_compatible(int major, int minor, int dev)
  {
    // Reference value when all fields are equal
    constexpr int VERSION_EQUAL = (1 << 4) | (1 << 2) | (1 << 0);
    return validate_version(major, minor, dev) >= VERSION_EQUAL;
  }
 
  void finalise();

  struct SimulationInstance
  {
  public:
    SimulationInstance(const SimulationInstance&) = delete;
    SimulationInstance(SimulationInstance&&) = default;
    SimulationInstance& operator=(const SimulationInstance&) = delete;
    SimulationInstance& operator=(SimulationInstance&&) = default;

    SimulationInstance() = delete;
    ~SimulationInstance();

    ApiResult apply(bool to_load) noexcept;

    ApiResult apply() noexcept;

    ApiResult apply_load() noexcept;
 
    ApiResult
    register_mixture_composition(std::span<std::string> names) noexcept;
 
    ApiResult register_mixture_composition(
        std::initializer_list<std::string_view> names) noexcept;

    ApiResult
    register_parameters(Core::UserControlParameters&& params) noexcept;

    bool register_result_path(std::string_view path);
 
    ApiResult
    register_initial_condition(Core::ScalarFactory::ScalarVariant&& type);
    ApiResult register_initialiser_file_path(std::string_view path);
    ApiResult register_cma_path(std::string_view path);

    bool register_serde(std::string_view path);

    ApiResult register_model_name(std::string_view path);
 
    ApiResult add_feed(Simulation::Feed::FeedDescriptor feed_type, Phase phase);
 
    ApiResult set_mtr(Simulation::MassTransfer::Type::MtrTypeVariant&& variant);
 
    void set_auto_mtr();
 
    ApiResult
    register_scalar_initiazer(Core::ScalarFactory::ScalarVariant&& var);

    [[nodiscard]] int get_id() const;
 
    [[nodiscard]] const ExecInfo& get_exec_info() const;

    ApiResult exec() noexcept;
 
    void
    set_logger(std::shared_ptr<IO::Logger> _logger)
    {
 
      logger = std::move(_logger);
    }
 
    [[nodiscard]] auto&
    get_logger() const
    {
      return logger;
    }

    static std::optional<std::unique_ptr<SimulationInstance>>
    init(int argc,
         char** argv,
         std::optional<std::size_t> run_id = std::nullopt) noexcept;
 
    static std::vector<std::string> get_model_list() noexcept;
 
  private:
    int id{}; 

    SimulationInstance(int argc,
                       char** argv,
                       std::optional<std::size_t> run_id);
 
    std::shared_ptr<IO::Logger> logger;
 
    std::shared_ptr<Mixture::SpecieTable> m_table;
 
    std::optional<Core::ScalarFactory::ScalarVariant> scalar_initializer_variant
        = std::nullopt;
    Core::CaseData _data;               
    Core::UserControlParameters params; 
    bool loaded = false;  
    bool applied = false; 
    bool registered = false; 
    std::optional<Simulation::Feed::SimulationFeed> feed
        = std::nullopt; 
    std::optional<Simulation::MassTransfer::Type::MtrTypeVariant> mtr_type
        = std::nullopt;
 
    bool auto_mtr;
  };
 
} // namespace Api
#endif