api.hpp

#ifndef __BIOMC_API_HPP__
#define __BIOMC_API_HPP__
 
#include "common/execinfo.hpp"
#include "core/scalar_factory.hpp"
#include <api/results.hpp>
#include <core/case_data.hpp>
#include <core/simulation_parameters.hpp>
#include <cstdint>
#include <cstdlib>
#include <memory>
#include <optional>
#include <simulation/feed_descriptor.hpp>
#include <span>
#include <string_view>
 
namespace Api
{
 
  void finalise();
 
  struct SimulationInstance
  {
  public:
    SimulationInstance(const SimulationInstance&) = delete;
    SimulationInstance(SimulationInstance&&) = default;
    SimulationInstance& operator=(const SimulationInstance&) = delete;
    SimulationInstance& operator=(SimulationInstance&&) = default;
 
    static std::optional<std::unique_ptr<SimulationInstance>>
    init(int argc, char** argv, std::optional<std::size_t> run_id = std::nullopt) noexcept;
 
    SimulationInstance() = delete;
    ~SimulationInstance();
 
    ApiResult apply(bool to_load) noexcept;
 
    ApiResult apply() noexcept;
 
    ApiResult apply_load() 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);
    bool register_cma_path(std::string_view path, bool recursive = false);
 
    bool register_serde(std::string_view path);
 
    ApiResult register_model_name(std::string_view path);
 
    bool set_feed(Simulation::Feed::FeedDescritor feed_variant,bool gas=false);
 
    bool set_feed_constant(double _flow,
                           std::span<double> _concentration,
                           std::span<std::size_t> _position,
                           std::span<std::size_t> _species,
                           bool gas = false,
                           bool fed_batch = false);
 
    bool set_feed_constant_from_rvalue(double _f,
                                       std::vector<double>&& _target,
                                       std::vector<std::size_t>&& _position,
                                       std::vector<std::size_t>&& _species,
                                       bool gas = false,
                                       bool fed_batch = false);
 
    ApiResult register_scalar_initiazer(Core::ScalarFactory::ScalarVariant&& var);
 
    [[nodiscard]] int get_id() const;
 
    [[nodiscard]] const ExecInfo& get_exec_info() const
    {
      return _data.exec_info;
    }
 
    ApiResult exec() noexcept;
 
  private:
    int id{}; 
 
    SimulationInstance(int argc, char** argv, std::optional<std::size_t> run_id);
 
    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; 
  };
 
} // namespace Api
#endif