datamodel_xml_configurationtoxml_10.h

Go to the documentation of this file.

 
#ifndef MAPPING_CONFIGURATION_TO_XML_FACTORY_10_H_INCLUDED
#define MAPPING_CONFIGURATION_TO_XML_FACTORY_10_H_INCLUDED
 
#include <ddl/mapping/datamodel/datamodel_configuration.h>
#include <ddl/mapping/datamodel/datamodel_xml_configurationtoxml_base.h>
#include <ddl/utilities/string_check.h>
 
#include <sstream>
#include <stdexcept>
#include <string>
 
namespace ddl {
namespace mapping {

inline std::string getMapping10FunctionCallAttributes(
    const datamodel::Assignment& assignment,
    [[maybe_unused]] const std::string& current_target_name,
    const datamodel::MappingConfiguration::Functions& functions,
    std::vector<std::pair<std::string, std::string>>& attributes_to_set)
{
    
    const auto function_call = assignment.getFunctionCall();
    const auto& parameters = assignment.getParameterValues();
    std::string error_message;
    if (function_call.function_name == "simulation_time") {
        if (parameters.getSize() == 0) {
            attributes_to_set.push_back({"function", "simulation_time()"});
        }
        else {
            error_message = "invalid parameter count for simulation_time()";
        }
    }
    else if (function_call.function_name == "trigger_counter") {
        if (parameters.getSize() == 1) {
            const auto trigger_count = parameters.get("update_counter");
            if (trigger_count &&
                trigger_count->getInternalValue().value_name == "update_counter" &&
                trigger_count->getInternalValue().name.empty()) {
                attributes_to_set.push_back({"function", "trigger_counter()"});
            }
            else {
                error_message = "invalid parameter value for trigger_counter() in Version 1.0";
            }
        }
        else if (parameters.getSize() == 2) {
            const auto modulo = parameters.get("modulo");
            const auto trigger_count = parameters.get("update_counter");
            if (trigger_count && modulo &&
                trigger_count->getInternalValue().value_name == "update_counter" &&
                trigger_count->getInternalValue().name.empty() &&
                utility::isInteger(modulo->getConstValue().value)) {
                attributes_to_set.push_back(
                    {"function", "trigger_counter(" + modulo->getConstValue().value + ")"});
            }
            else {
                error_message =
                    "invalid parameter value for trigger_counter(modulo) in Version 1.0";
            }
        }
        else {
            error_message = "invalid parameter count for trigger_counter(modulo)";
        }
    }
    else if (function_call.function_name == "was_received") {
        if (parameters.getSize() == 1) {
            const auto trigger_count = parameters.get("update_counter");
            if (trigger_count && !trigger_count->getInternalValue().name.empty()) {
                attributes_to_set.push_back(
                    {"function", "received(" + trigger_count->getInternalValue().name + ")"});
            }
            else {
                error_message = "invalid parameter value for received(source) in Version 1.0";
            }
        }
        else {
            error_message = "invalid parameter count for trigger_counter(module)";
        }
    }
    else {
        const auto functions_instance = functions.get(function_call.function_name);
        if (functions_instance) {
            const auto& function_type = functions_instance->getType();
            if (function_type == "ddl_enum_table" || function_type == "polynomial") {
                if (parameters.getSize() == 1) {
                    auto source = parameters.get("value");
                    if (source &&
                        source->getType() == datamodel::ParameterValue::Type::source_value) {
                        const auto source_value = source->getSourceValue();
                        attributes_to_set.push_back(
                            {"from", source_value.name + "." + source_value.value_name});
                        attributes_to_set.push_back(
                            {"transformation", function_call.function_name});
                    }
                    else {
                        error_message = "invalid parameter for transformation";
                    }
                }
                else {
                    error_message = "invalid parameter count for transformation";
                }
            }
            else {
                error_message = "unknown function_type '" + function_type + "' in Version 1.0";
            }
        }
        else {
            error_message = "unknown function in Version 1.0";
        }
    }
    if (!error_message.empty()) {
        return "can not resolve module call to a transformation or function: " + error_message;
    }
    else {
        return {};
    }
}

template <typename DomNodeType>
struct MappingConfigurationToXMLFactory10 {
    using xml_base_type = MappingConfigurationToXMLFactoryBase<DomNodeType>;

    static void createNode(DomNodeType& parent_node, const datamodel::Source& source)
    {
        DomNodeType source_node = parent_node.createChild("source");
        source_node.setAttribute("name", source.getName());
        const auto& source_type = source.getType();
        if (source_type.empty() || source_type == "ddl") {
            const auto type = source.getProperties().get("type");
            if (type) {
                source_node.setAttribute("type", type->getValue());
            }
            else {
                throw Error("createNode",
                            {"source", source.getName()},
                            "no type set in source for Version 1.0");
            }
        }
        else {
            throw Error("Mapping10::createNode",
                        {"source", source.getName()},
                        "invalid source_type '" + source_type + "' used for Version 1.0");
        }
    }

    static void resolveFunctionCall(DomNodeType& assignment_node,
                                    const datamodel::Assignment& assignment,
                                    const std::string& current_target_name,
                                    const datamodel::MappingConfiguration::Functions& functions)
    {
        std::vector<std::pair<std::string, std::string>> attributes_to_set;
        auto error_message = getMapping10FunctionCallAttributes(
            assignment, current_target_name, functions, attributes_to_set);
 
        if (!error_message.empty()) {
            const auto function_call = assignment.getFunctionCall();
            throw Error("Mapping10::resolveFunctionCall",
                {assignment.getName(), function_call.function_name},
                        "can not resolve function call to a transformation or v1.0 function: " +
                            error_message);
        }
        else {
            for (const auto& current_attribute: attributes_to_set) {
                assignment_node.setAttribute(current_attribute.first, current_attribute.second);
            }
        }
    }

    static void createNode(DomNodeType& parent_node,
                           const datamodel::Assignment& assignment,
                           const std::string& current_target_name,
                           const datamodel::MappingConfiguration::Functions& functions)
    {
        DomNodeType assignment_node = parent_node.createChild("assignment");
        assignment_node.setAttribute("to", assignment.getTo());
        if (assignment.getType() == datamodel::Assignment::Type::const_value) {
            assignment_node.setAttribute("constant", assignment.getConstValue().value);
        }
        else if (assignment.getType() == datamodel::Assignment::Type::source_value) {
            const auto source_value = assignment.getSourceValue();
            if (source_value.value_name.empty()) {
                assignment_node.setAttribute("from", source_value.name);
            }
            else {
                assignment_node.setAttribute("from",
                                             source_value.name + "." + source_value.value_name);
            }
        }
        else if (assignment.getType() == datamodel::Assignment::Type::function_call) {
            // we need to decide if the function_call is valid for version 1.0
            resolveFunctionCall(assignment_node, assignment, current_target_name, functions);
        }
        else {
            throw Error(
                "createNode", {"assignment", assignment.getName()}, "invalid assignment type");
        }
    }

    static void createNode(DomNodeType& parent_node, const datamodel::Trigger& trigger)
    {
        DomNodeType trigger_node = parent_node.createChild("trigger");
        if (!trigger.getTimeStrategy().empty()
            && trigger.getTimeStrategy() != datamodel::Trigger::strategy_trigger) {
            throw Error("createNode",
                        {"trigger"},
                        "invalid time strategy '" + trigger.getTimeStrategy() +
                            "' for Version 1.0");
        }
        if (trigger.getType() == datamodel::Trigger::Type::source) {
            trigger_node.setAttribute("type", "signal");
            trigger_node.setAttribute("variable", trigger.getSource().source_name);
        }
        else if (trigger.getType() == datamodel::Trigger::Type::period) {
            trigger_node.setAttribute("type", "periodic");
            const auto period = trigger.getPeriod();
            trigger_node.setAttribute("period", period.time);
            trigger_node.setAttribute("unit", period.unit);
        }
        else if (trigger.getType() == datamodel::Trigger::Type::data) {
            trigger_node.setAttribute("type", "data");
            const auto data = trigger.getData();
            trigger_node.setAttribute("variable", data.source_name + "." + data.source_value_name);
            trigger_node.setAttribute("operator", data.operation);
            trigger_node.setAttribute("value", data.value);
        }
        else {
            throw Error("createNode", {"trigger"}, "invalid tigger type for Version 1.0");
        }
    }

    static void createNode(DomNodeType& parent_node,
                           const datamodel::Target& target,
                           const datamodel::MappingConfiguration::Functions& functions)
    {
        DomNodeType target_node = parent_node.createChild("target");
        target_node.setAttribute("name", target.getName());
        const auto& target_type = target.getType();
        if (target_type.empty() || target_type == "ddl") {
            const auto type = target.getProperties().get("type");
            if (type) {
                target_node.setAttribute("type", type->getValue());
            }
            else {
                throw Error("createNode",
                            {"target", target.getName()},
                            "no type set in target for Version 1.0");
            }
        }
        else {
            throw Error("createNode",
                        {"target", target.getName()},
                        "invalid target_type '" + target_type + "' used for Version 1.0");
        }
 
        // Assignments
        for (const auto& current_assignment: target.getAssignments()) {
            createNode(target_node, *(current_assignment), target.getName(), functions);
        }
 
        // Triggers
        for (const auto& current_trigger: target.getTriggers()) {
            createNode(target_node, *(current_trigger));
        }
    }

    template <typename PropertiesType>
    static void setPropertyAsAttribute(DomNodeType& parent_node,
                                       const std::string& name,
                                       const PropertiesType& properties,
                                       bool is_mandatory)
    {
        const auto prop = properties.get(name);
        if (prop) {
            parent_node.setAttribute(name, prop->getValue());
        }
        else {
            if (is_mandatory) {
                throw Error("Mapping10::setPropertyAsAttribute",
                            {parent_node.getName(), name},
                            "can not find mandatory property for transformation");
            }
        }
    }

    static void setEnumTableNodes(DomNodeType& dom_node,
                                  const std::shared_ptr<const datamodel::Property>& prop)
    {
        if (prop) {
            std::stringstream value(prop->getValue());
            std::string line;
            while (std::getline(value, line)) {
                const auto split_pos = line.find('=');
                if (split_pos != std::string::npos && split_pos != line.size() - 1 &&
                    split_pos != 0) {
                    DomNodeType conversion_node = dom_node.createChild("conversion");
                    conversion_node.setAttribute("from", line.substr(0, split_pos));
                    conversion_node.setAttribute(
                        "to", line.substr(split_pos + 1, line.size() - split_pos - 1));
                }
            }
        }
    }

    static void createNode(DomNodeType& parent_node, const datamodel::Function& function_inst)
    {
        if (function_inst.getType() == "simulation_time" ||
            function_inst.getType() == "was_received" ||
            function_inst.getType() == "trigger_counter") {
            // we ignore them
        }
        else if (function_inst.getType() == "polynomial") {
            DomNodeType polynomial_node = parent_node.createChild("polynomial");
            polynomial_node.setAttribute("name", function_inst.getName());
            setPropertyAsAttribute(polynomial_node, "a", function_inst.getProperties(), false);
            setPropertyAsAttribute(polynomial_node, "b", function_inst.getProperties(), false);
            setPropertyAsAttribute(polynomial_node, "c", function_inst.getProperties(), false);
            setPropertyAsAttribute(polynomial_node, "d", function_inst.getProperties(), false);
            setPropertyAsAttribute(polynomial_node, "e", function_inst.getProperties(), false);
        }
        else if (function_inst.getType() == "ddl_enum_table") {
            DomNodeType enum_table_node = parent_node.createChild("enum_table");
            enum_table_node.setAttribute("name", function_inst.getName());
            setPropertyAsAttribute(enum_table_node, "from", function_inst.getProperties(), true);
            setPropertyAsAttribute(enum_table_node, "to", function_inst.getProperties(), true);
            setPropertyAsAttribute(enum_table_node, "default", function_inst.getProperties(), true);
            setEnumTableNodes(enum_table_node, function_inst.getProperties().get("table"));
        }
        else {
            throw Error("Mapping10::createNode",
                        {function_inst.getName()},
                        "unknown module_type '" + function_inst.getType() + " in Version 1.0");
        }
    }

    static void createNode(DomNodeType& parent_node, const datamodel::MappingConfiguration& config)
    {
        // header was written by MappingConfigurationToXMLFactory already
 
        DomNodeType sources_node = parent_node.createChild("sources");
        // write sources
        const auto& sources = config.getSources();
        for (const auto& source: sources) {
            createNode(sources_node, *(source.second));
        }
 
        DomNodeType targets_node = parent_node.createChild("targets");
        // write targets
        const auto& targets = config.getTargets();
        const auto& functions = config.getFunctions();
        for (const auto& target: targets) {
            createNode(targets_node, *(target.second), functions);
        }
 
        DomNodeType functions_node = parent_node.createChild("transformations");
        // write modules
        for (const auto& function_inst: functions) {
            createNode(functions_node, *(function_inst.second));
        }
    }
};
} // namespace mapping
} // namespace ddl
 
#endif // MAPPING_CONFIGURATION_TO_XML_FACTORY_10_H_INCLUDED