transformation_schema.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include <nlohmann/json.hpp>
 
namespace sdfg {
namespace transformations {

const std::string& transformation_schema_text();

const nlohmann::json& transformation_schema();

inline bool validate_transformation_schema(const nlohmann::json& j, std::string& error_out) {
    if (!j.is_object()) {
        error_out = "transformation description must be an object";
        return false;
    }
 
    // transformation_type
    if (!j.contains("transformation_type")) {
        error_out = "missing 'transformation_type'";
        return false;
    }
    if (!j["transformation_type"].is_string() || j["transformation_type"].get<std::string>().empty()) {
        error_out = "'transformation_type' must be a non-empty string";
        return false;
    }
 
    // parameters (optional, for backward compatibility; must be an object when present)
    if (j.contains("parameters") && !j["parameters"].is_object()) {
        error_out = "'parameters' must be an object";
        return false;
    }
 
    // subgraph
    if (!j.contains("subgraph")) {
        error_out = "missing 'subgraph'";
        return false;
    }
    const auto& subgraph = j["subgraph"];
    if (!subgraph.is_object()) {
        error_out = "'subgraph' must be an object";
        return false;
    }
    for (std::size_t i = 0; i < subgraph.size(); ++i) {
        const auto key = std::to_string(i);
        if (!subgraph.contains(key)) {
            error_out = "'subgraph' keys must be contiguous indices; missing '" + key + "'";
            return false;
        }
        const auto& node = subgraph[key];
        if (!node.is_object()) {
            error_out = "'subgraph[" + key + "]' must be an object";
            return false;
        }
        if (!node.contains("element_id")) {
            error_out = "'subgraph[" + key + "]' must have an 'element_id'";
            return false;
        }
        const auto& element_id = node["element_id"];
        const bool non_negative_integer = element_id.is_number_unsigned() ||
                                          (element_id.is_number_integer() && element_id.get<long long>() >= 0);
        if (!non_negative_integer) {
            error_out = "'subgraph[" + key + "]' must have a non-negative integer 'element_id'";
            return false;
        }
        if (!node.contains("type") || !node["type"].is_string()) {
            error_out = "'subgraph[" + key + "]' must have a string 'type'";
            return false;
        }
    }
 
    // Reject unknown top-level keys to keep the schema strict.
    for (auto it = j.begin(); it != j.end(); ++it) {
        if (it.key() != "transformation_type" && it.key() != "subgraph" && it.key() != "parameters") {
            error_out = "unexpected top-level key '" + it.key() + "'";
            return false;
        }
    }
 
    return true;
}
 
} // namespace transformations
} // namespace sdfg