DataDictionary.hpp

Go to the documentation of this file.

#pragma once

 
#include <cerrno>
#include <cstddef>
#include <cstring>
#include <fstream>
#include <icarus/core/Error.hpp>
#include <icarus/signal/Signal.hpp>
#include <nlohmann/json.hpp>
#include <string>
#include <vector>
#include <yaml-cpp/yaml.h>
 
namespace icarus {
 
namespace detail {
template <typename WriteFunc>
inline void WriteToFile(const std::string &path, WriteFunc write_content) {
    std::ofstream file(path);
    if (!file.is_open()) {
        throw IOError("open", path, "Failed to open file for writing");
    }
    write_content(file);
    if (file.fail()) {
        throw IOError("write", path, "Failed to write to file");
    }
}
} // namespace detail

struct DataDictionary {
    struct ComponentEntry {
        std::string name; 
        std::string type; 
 
        std::vector<SignalDescriptor> outputs;    
        std::vector<SignalDescriptor> inputs;     
        std::vector<SignalDescriptor> parameters; 
        std::vector<SignalDescriptor> config;     
    };

    std::vector<ComponentEntry> components;
 
    // Summary statistics
    std::size_t total_outputs = 0;
    std::size_t total_inputs = 0;
    std::size_t total_parameters = 0;
    std::size_t total_config = 0;
    std::size_t integrable_states = 0;
    std::size_t unwired_inputs = 0;
 
    static void AppendSignalsToYAML(YAML::Emitter &out, const std::string &key,
                                    const std::vector<SignalDescriptor> &signals) {
        if (signals.empty()) {
            return;
        }
 
        out << YAML::Key << key << YAML::Value << YAML::BeginSeq;
        for (const auto &sig : signals) {
            out << YAML::BeginMap;
            out << YAML::Key << "name" << YAML::Value << sig.name;
            out << YAML::Key << "unit" << YAML::Value << sig.unit;
            out << YAML::Key << "description" << YAML::Value << sig.description;
            if (!sig.wired_to.empty()) {
                out << YAML::Key << "wired_to" << YAML::Value << sig.wired_to;
            }
            if (sig.is_integrable) {
                out << YAML::Key << "is_integrable" << YAML::Value << true;
            }
            out << YAML::EndMap;
        }
        out << YAML::EndSeq;
    }
 
    void AppendComponentsToYAML(YAML::Emitter &out) const {
        out << YAML::Key << "components" << YAML::Value << YAML::BeginSeq;
        for (const auto &comp : components) {
            out << YAML::BeginMap;
            out << YAML::Key << "name" << YAML::Value << comp.name;
            out << YAML::Key << "type" << YAML::Value << comp.type;
 
            AppendSignalsToYAML(out, "outputs", comp.outputs);
            AppendSignalsToYAML(out, "inputs", comp.inputs);
            AppendSignalsToYAML(out, "parameters", comp.parameters);
            AppendSignalsToYAML(out, "config", comp.config);
 
            out << YAML::EndMap;
        }
        out << YAML::EndSeq;
    }
 
    [[nodiscard]] nlohmann::json ToJSONValue() const {
        nlohmann::json j;
 
        j["summary"]["total_outputs"] = total_outputs;
        j["summary"]["total_inputs"] = total_inputs;
        j["summary"]["total_parameters"] = total_parameters;
        j["summary"]["total_config"] = total_config;
        j["summary"]["integrable_states"] = integrable_states;
        j["summary"]["unwired_inputs"] = unwired_inputs;
 
        auto to_json_signals = [](const std::vector<SignalDescriptor> &signals) {
            nlohmann::json arr = nlohmann::json::array();
            for (const auto &sig : signals) {
                nlohmann::json jsig;
                jsig["name"] = sig.name;
                jsig["unit"] = sig.unit;
                jsig["description"] = sig.description;
                if (!sig.wired_to.empty()) {
                    jsig["wired_to"] = sig.wired_to;
                }
                if (sig.is_integrable) {
                    jsig["is_integrable"] = true;
                }
                arr.push_back(jsig);
            }
            return arr;
        };
 
        j["components"] = nlohmann::json::array();
        for (const auto &comp : components) {
            nlohmann::json jcomp;
            jcomp["name"] = comp.name;
            jcomp["type"] = comp.type;
            jcomp["outputs"] = to_json_signals(comp.outputs);
            jcomp["inputs"] = to_json_signals(comp.inputs);
            jcomp["parameters"] = to_json_signals(comp.parameters);
            jcomp["config"] = to_json_signals(comp.config);
            j["components"].push_back(jcomp);
        }
 
        return j;
    }

    void ComputeStats() {
        total_outputs = 0;
        total_inputs = 0;
        total_parameters = 0;
        total_config = 0;
        integrable_states = 0;
        unwired_inputs = 0;
 
        for (const auto &comp : components) {
            total_outputs += comp.outputs.size();
            total_inputs += comp.inputs.size();
            total_parameters += comp.parameters.size();
            total_config += comp.config.size();
 
            for (const auto &output : comp.outputs) {
                if (output.is_integrable) {
                    ++integrable_states;
                }
            }
 
            for (const auto &input : comp.inputs) {
                if (input.wired_to.empty()) {
                    ++unwired_inputs;
                }
            }
        }
    }

    void ToYAML(const std::string &path) const {
        YAML::Emitter out;
        out << YAML::BeginMap;
 
        // Summary section
        out << YAML::Key << "summary" << YAML::Value << YAML::BeginMap;
        out << YAML::Key << "total_outputs" << YAML::Value << total_outputs;
        out << YAML::Key << "total_inputs" << YAML::Value << total_inputs;
        out << YAML::Key << "total_parameters" << YAML::Value << total_parameters;
        out << YAML::Key << "total_config" << YAML::Value << total_config;
        out << YAML::Key << "integrable_states" << YAML::Value << integrable_states;
        out << YAML::Key << "unwired_inputs" << YAML::Value << unwired_inputs;
        out << YAML::EndMap;
 
        AppendComponentsToYAML(out);
        out << YAML::EndMap;
 
        detail::WriteToFile(path, [&](std::ofstream &file) { file << out.c_str(); });
    }

    void ToJSON(const std::string &path) const {
        auto j = ToJSONValue();
 
        detail::WriteToFile(path, [&](std::ofstream &file) { file << j.dump(2); });
    }
};
 
} // namespace icarus