IOInterface Class Reference

#include <interface.hpp>

Public Member Functions
	IOInterface (int argc, char *argv[])
	Construct a new Interface and load the TOML configuration file.
template<typename Derived>
void	write2csv (const std::string &filename, const Eigen::MatrixBase< Derived > &mat_data, const std::string &comment) const
	Write a matrix to a CSV file in scientific notation.
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
template<typename T>
T	load_scalar (const std::string &toml_path) const
	Load a scalar value from the TOML input file using a dotted path.

Data Fields
toml::table	m_input

Detailed Description

Parameters

m_output_dir

Output directory based on toml input

Definition at line 15 of file interface.hpp.

Constructor & Destructor Documentation

IOInterface()

IOInterface ( int argc, char * argv[] )

explicit

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.

Parameters

argc	Number of command-line arguments.
argv	Command-line argument array.

Definition at line 6 of file interface.cpp.

                                               {
 
    std::cout << " -> Initializing Interface ..." << std::endl;
    if (argc != 1){
        try {
            if (!std::filesystem::exists(argv[1])) {
                std::cerr << "[Interface] Config file not found: " << argv[1] << '\n';
            }
            m_input = toml::parse_file(argv[1]);
            std::cout << "###  Settings from TOML:  ###\n" << m_input << std::endl;
        }
        catch (const toml::parse_error& err) {
            std::cerr << "[Interface] Parse error: " << err.description()
                << "\n  at " << err.source().begin << '\n';
        }
    } else {
        throw std::runtime_error("Usage: <program> <config.toml>");
    }
    // --- Create output directory on initialization ---
    std::filesystem::path output_dir = m_input.get("output")->value_or("");
    try {
        if (!output_dir.empty()) {
            std::filesystem::create_directories(output_dir);
            std::cout << " -> Output directory ready: " << output_dir << std::endl;
        }
        else {
            throw std::runtime_error("No output directory defined in config.toml");
        }
    }
    catch (const std::filesystem::filesystem_error& e) {
        throw std::runtime_error(
            "Failed to create output directory '" + output_dir.string() + "': " + e.what()
        );
    }
};

~IOInterface()

~IOInterface

(

)

Definition at line 56 of file interface.cpp.

                          {
    try {
        std::filesystem::path output_dir = m_input.get("output")->value_or("");
 
        if (output_dir.empty()) {
            std::cerr << "[Interface] No output directory, cannot write config_used.toml\n";
            return;
        }
 
        std::filesystem::path out_file = output_dir / "config_used.toml";
        std::ofstream os(out_file);
 
        if (!os.is_open()) {
            std::cerr << "[Interface] Failed to write config_used.toml\n";
            return;
        }
 
        os << m_input << "\n";   // toml++ automatically formats the table
        os.close();
 
        std::cout << " -> Wrote config_used.toml to " << out_file << std::endl;
    }
    catch (const std::exception& e) {
        std::cerr << "[Interface] Error writing config_used.toml: " << e.what() << "\n";
    }
}

Member Function Documentation

load_scalar()

template<typename T>

T load_scalar ( const std::string & toml_path ) const

inline

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().

Template Parameters

T	The C++ type to convert the TOML value into.

Parameters

toml_path

Dotted path to the value in the TOML configuration.

Returns

The loaded value, converted to type T.

Exceptions

std::runtime_error

if the path does not exist or cannot be converted.

Definition at line 134 of file interface.hpp.

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

load_vector()

template<typename VecT>

VecT load_vector ( const std::string & toml_path ) const

inline

Definition at line 85 of file interface.hpp.

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

write2csv() [1/2]

template<typename Derived>

void write2csv ( const std::string & filename, const Eigen::MatrixBase< Derived > & mat_data, const std::string & comment ) const

inline

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.

Parameters

filename	The path and name of the output CSV file.
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 also

Eigen::MatrixXd

Definition at line 55 of file interface.hpp.

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

write2csv() [2/2]

void write2csv	(	const std::string &	filename,
		Eigen::VectorXd &	vector_data,
		const std::string &	comment ) const

Definition at line 42 of file interface.cpp.

                                                                                                                 {
    std::cout << " Writing " << filename << std::endl;
 
    std::filesystem::path output_dir = m_input.get("output")->value_or("");
    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 << "# data length " << vector_data.size() << comment << std::endl;
    output_stream << std::scientific << vector_data << '\n';
}

Field Documentation

m_input

toml::table m_input

Definition at line 17 of file interface.hpp.

---

The documentation for this class was generated from the following files:

• src/interface.hpp
• src/interface.cpp