interface.hpp

#pragma once
 
#include <string>
#include <filesystem>
#include <iostream>
 
#include <toml++/toml.hpp>
#include <Eigen/Dense>
 
/**
 * @brief 
 * 
 * @param m_output_dir Output directory based on toml input
 */
class IOInterface{
public:
    toml::table m_input;
 
    /**
     * @brief Construct a new Interface and load the TOML configuration file.
     * 
     * Expects the first command-line argument (argv[1]) to be the path
     * to the TOML configuration file.
     * 
     * @param argc Number of command-line arguments.
     * @param argv Command-line argument array.
     */
    explicit IOInterface(int argc, char* argv[]);
    ~IOInterface();                // add destructor
 
    /**
    * @brief Write a matrix to a CSV file in scientific notation.
    *
    * This method exports the content of an Eigen::MatrixXd to a CSV-formatted
    * text file. Each row of the matrix is written as a line in the file, with
    * values formatted using scientific notation. The output file will be
    * overwritten if it already exists.
    *
    * @param filename
    *        The path and name of the output CSV file.
    *
    * @param matrix_data
    *        The matrix whose contents will be written to the file. Each row
    *        is written sequentially as a separate line.
    *
    * @note
    * - Values are written using `std::scientific` formatting.
    * - No header row is included in the output.
    * - Elements in each row are written using Eigen’s default stream operator,
    *   which separates values with spaces rather than commas unless customized.
    *
    * @see Eigen::MatrixXd
    */
    template <typename Derived>
    void write2csv(const std::string& filename,
        const Eigen::MatrixBase<Derived>& mat_data,
        const std::string& comment) const {
 
        std::filesystem::path output_dir = m_input.get("output")->value_or("");
 
        std::cout << " Writing " << filename << std::endl;
 
        std::ofstream output_stream(output_dir / filename);
        if (!output_stream.is_open()) {
            throw std::runtime_error("Cannot open file: " +
                (output_dir / filename).string());
        }
 
        output_stream << std::scientific;
        const int rows = mat_data.rows();
        const int cols = mat_data.cols();
        output_stream << "# Data size (" << rows << ", " << cols << ")" << comment << std::endl;
 
        for (int i = 0; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                output_stream << mat_data(i, j);
                if (j < cols - 1) output_stream << ' ';   // single whitespace
            }
            output_stream << '\n';
        }
    }
    void write2csv(const std::string& filename, Eigen::VectorXd& vector_data, const std::string& comment) const;
 
    template <typename VecT>
    VecT load_vector(const std::string& toml_path) const
    {
        using Scalar = typename VecT::Scalar;
 
        // Access array in TOML
        auto arr = m_input.at_path(toml_path).as_array();
        if (!arr) {
            throw std::runtime_error("Missing " + toml_path + " array in TOML file.");
        }
 
        const std::size_t toml_size = arr->size();
        // Create resulting vector
        VecT vec;
 
        // Handle fixed-size vs dynamic-size
        if constexpr (VecT::SizeAtCompileTime == Eigen::Dynamic) {
            vec.resize(toml_size);
        } else {
            if (toml_size != VecT::SizeAtCompileTime) {
                throw std::runtime_error(
                    "Size mismatch for " + toml_path +
                    ": expected " + std::to_string(VecT::SizeAtCompileTime) +
                    ", got " + std::to_string(toml_size)
                );
            }
        }
 
        // Fill vector
        for (std::size_t i = 0; i < toml_size; ++i) {
            vec(i) = static_cast<Scalar>(arr->at(i).value_or(Scalar{}));
        }
 
        return vec;
    }
 
    /**
    * @brief Load a scalar value from the TOML input file using a dotted path.
    *
    * This function loads a single scalar value (int, double, bool, string, …)
    * from the TOML configuration. The path is resolved using toml::node::at_path().
    * 
    * @tparam T  The C++ type to convert the TOML value into.
    * @param toml_path  Dotted path to the value in the TOML configuration.
    *
    * @return The loaded value, converted to type T.
    *
    * @throws std::runtime_error if the path does not exist or cannot be converted.
    */
    template <typename T>
    T load_scalar(const std::string& toml_path) const
    {
        // Try to access the node at the given path
        auto node = m_input.at_path(toml_path);
 
        if (!node) {
            throw std::runtime_error("Missing scalar value at path: " + toml_path);
        }
 
        // Extract the value and convert
        auto val = node.value<T>();
        if (!val.has_value()) {
            throw std::runtime_error(
                "Type mismatch or invalid value at path: " + toml_path
            );
        }
 
        return *val;
    }
 
};