main.cpp File Reference

Entry point for the FERS command-line interface (CLI). More...

#include <filesystem>
#include <format>
#include <fstream>
#include <iostream>
#include <libfers/api.h>
#include <string>
#include "arg_parser.h"
#include "cli_paths.h"

Include dependency graph for main.cpp:

Go to the source code of this file.

Namespaces
namespace	logging

Macros
#define	LOG(level, ...)

Functions
static std::string	logging::getLevelString (fers_log_level_t l)
int	main (const int argc, char *argv[])

Detailed Description

Entry point for the FERS command-line interface (CLI).

This executable acts as a wrapper around the libfers core library. It parses command-line arguments, uses the libfers C-API to load and run a simulation, and reports progress to the console.

Definition in file main.cpp.

Macro Definition Documentation

LOG

#define LOG	(		level,
			...
	)

Value:

    do                                                                                                                 \
    {                                                                                                                  \
        std::string _msg = std::format(__VA_ARGS__);                                                                   \
        fers_log(level, _msg.c_str());                                                                                 \
    }                                                                                                                  \
    while (0)

Definition at line 49 of file main.cpp.

    {                                                                                                                  \
        std::string _msg = std::format(__VA_ARGS__);                                                                   \
        fers_log(level, _msg.c_str());                                                                                 \
    }                                                                                                                  \
    while (0)

Function Documentation

main()

int main	(	const int	argc,
		char *	argv[]
	)

Definition at line 58 of file main.cpp.

{
    // Parse command-line arguments using the local arg parser
    const auto config_result = core::parseArguments(argc, argv);
    if (!config_result)
    {
        if (config_result.error() != "Help requested." && config_result.error() != "Version requested." &&
            config_result.error() != "No arguments provided.")
        {
            // Use basic stderr here because logging isn't configured yet
            std::cerr << "[ERROR] Argument parsing error: " << config_result.error() << '\n';
            return 1;
        }
        return 0;
    }
 
    const auto& [script_file, log_level, num_threads, validate, log_file, generate_kml, kml_file, output_dir] =
        config_result.value();
 
    // Configure logging via the C API
    const char* log_file_ptr = log_file ? log_file->c_str() : nullptr;
    if (fers_configure_logging(log_level, log_file_ptr) != 0)
    {
        // If we can't configure logging, we must print to stderr manually
        char* err = fers_get_last_error_message();
        std::cerr << "[ERROR] Failed to configure logging: " << ((err != nullptr) ? err : "Unknown error") << '\n';
        fers_free_string(err);
        return 1;
    }
 
    LOG(FERS_LOG_INFO, "FERS CLI started. Using libfers backend.");
 
    LOG(FERS_LOG_DEBUG,
        "Running FERS with arguments: script_file={}, log_level={}, num_threads={}, validate={}, log_file={}",
        script_file, logging::getLevelString(log_level), num_threads, validate, log_file.value_or("None"));
 
    const std::filesystem::path final_out_dir = core::resolveOutputDir(script_file, output_dir);
 
    // Create a simulation context using the C-API
    fers_context_t* context = fers_context_create();
    if (context == nullptr)
    {
        LOG(FERS_LOG_FATAL, "Failed to create FERS simulation context.");
        return 1;
    }
 
    // Set the output directory via the C-API
    if (fers_set_output_directory(context, final_out_dir.string().c_str()) != 0)
    {
        char* err = fers_get_last_error_message();
        LOG(FERS_LOG_FATAL, "Failed to set output directory: {}", err ? err : "Unknown error");
        fers_free_string(err);
        fers_context_destroy(context);
        return 1;
    }
 
    // Load the scenario from file via the C-API
    LOG(FERS_LOG_INFO, "Loading scenario from '{}'...", script_file);
    if (fers_load_scenario_from_xml_file(context, script_file.c_str(), validate ? 1 : 0) != 0)
    {
        char* err = fers_get_last_error_message();
        LOG(FERS_LOG_FATAL, "Failed to load scenario: {}", err ? err : "Unknown error");
        fers_free_string(err);
        fers_context_destroy(context);
        return 1;
    }
 
    if (generate_kml)
    {
        const std::filesystem::path kml_output_path = core::resolveKmlOutputPath(script_file, final_out_dir, kml_file);
        const std::string kml_output_file = kml_output_path.string();
 
        LOG(FERS_LOG_INFO, "Generating KML file for scenario: {}", kml_output_file);
        if (fers_generate_kml(context, kml_output_file.c_str()) == 0)
        {
            LOG(FERS_LOG_INFO, "KML file generated successfully: {}", kml_output_file);
        }
        else
        {
            char* err = fers_get_last_error_message();
            LOG(FERS_LOG_FATAL, "Failed to generate KML file: {}", err ? err : "Unknown error");
            fers_free_string(err);
        }
 
        fers_context_destroy(context);
        return 0; // Exit after generating KML
    }
 
    // Set thread count via the C-API
    if (fers_set_thread_count(num_threads) != 0)
    {
        char* err = fers_get_last_error_message();
        LOG(FERS_LOG_ERROR, "Failed to set number of threads: {}", err ? err : "Unknown error");
        fers_free_string(err);
    }
 
    // Run the simulation via the C-API
    LOG(FERS_LOG_INFO, "Starting simulation...");
    if (fers_run_simulation(context, nullptr, nullptr) != 0)
    {
        char* err = fers_get_last_error_message();
        LOG(FERS_LOG_FATAL, "Simulation run failed: {}", err ? err : "Unknown error");
        fers_free_string(err);
        fers_context_destroy(context);
        return 1;
    }
    LOG(FERS_LOG_INFO, "Simulation completed successfully.");
 
    fers_context_destroy(context);
 
    return 0;
}

References fers_configure_logging(), fers_context_create(), fers_context_destroy(), fers_free_string(), fers_generate_kml(), fers_get_last_error_message(), fers_load_scenario_from_xml_file(), FERS_LOG_DEBUG, FERS_LOG_ERROR, FERS_LOG_FATAL, FERS_LOG_INFO, fers_run_simulation(), fers_set_output_directory(), fers_set_thread_count(), logging::getLevelString(), LOG, core::parseArguments(), core::resolveKmlOutputPath(), and core::resolveOutputDir().

Here is the call graph for this function: