datamodel_xml_configurationfromxml_10.h

Go to the documentation of this file.

 
#ifndef MAPPING_CONFIGURATION_FROM_XML_10_H_INCLUDED
#define MAPPING_CONFIGURATION_FROM_XML_10_H_INCLUDED
 
#include <ddl/mapping/datamodel/datamodel_configuration.h>
#include <ddl/mapping/datamodel/datamodel_xml_configurationfromxml_base.h>
 
#include <list>
 
namespace ddl {
namespace mapping {
template <typename DomNodeType>
struct MappingConfigurationFromXMLFactory10 {
    using xml_base_type = MappingConfigurationFromXMLFactoryBase<DomNodeType>;
    static constexpr auto mapping_reading_version = "Mapping10::";

    template <typename T>
    static utility::Optional<T> getAttributeMandatory(const DomNodeType& dom_node,
                                                      const std::string& attribute_name,
                                                      const std::string& additional_info = {})
    {
        return xml_base_type::template getAttribute<std::string>(
            dom_node,
            attribute_name,
            {},
            true,
            dom_node.getName() + additional_info + " tag has no mandatory '" + attribute_name +
                "' attribute",
            mapping_reading_version);
    }

    template <typename T>
    static utility::Optional<T> getAttribute(const DomNodeType& dom_node,
                                             const std::string& attribute_name)
    {
        return xml_base_type::template getAttribute<std::string>(dom_node, attribute_name);
    }

    static datamodel::Source createSource(const DomNodeType& dom_node)
    {
        const auto name = getAttributeMandatory<std::string>(dom_node, "name");
        const auto ddl_type = getAttributeMandatory<std::string>(dom_node, "type");
        return datamodel::Source(*name, "", {{"type", *ddl_type}});
    }

    static datamodel::Assignment::SourceValue getAsSourceValue(const std::string& variable)
    {
        const auto pos = variable.find_first_of('.');
        if (pos == std::string::npos || pos == variable.size() - 1) {
            return {variable, ""};
        }
        else {
            return {variable.substr(0, pos), variable.substr(pos + 1, variable.size() - (pos + 1))};
        }
    }

    static utility::Optional<std::string> parseFunctionParameter(const std::string& function_call)
    {
        const auto pos1 = function_call.find('(');
        const auto pos2 = function_call.find(')');
        if (pos1 == std::string::npos || pos2 == std::string::npos || pos1 >= pos2) {
            throw Error(
                "Mapping10::parseFunctionParameter", {function_call}, "invalid function call");
        }
        else if (pos1 + 1 == pos2) {
            return {};
        }
        else {
            return function_call.substr(pos1 + 1, pos2 - pos1 - 1);
        }
    }

    struct NeedFunctions {
        bool simulation_time_function = false;
        bool was_received_function = false;
        bool trigger_counter_function = false;
        
    };

    static std::pair<datamodel::Assignment::FunctionCall, std::vector<datamodel::ParameterValue>>
    createFunctionCall(const std::string& target_name,
                       const std::string& function_attribute,
                       NeedFunctions& need_functions)
    {
        constexpr auto update_counter = "update_counter";
        if (function_attribute == "simulation_time()") {
            need_functions.simulation_time_function = true;
            return {datamodel::Assignment::FunctionCall{"simulation_time"}, {}};
        }
        else if (function_attribute.find("trigger_counter") != std::string::npos) {
            const auto parameter = parseFunctionParameter(function_attribute);
            if (parameter) {
                if (utility::isInteger(*parameter)) {
                    need_functions.trigger_counter_function = true;
                    return {datamodel::Assignment::FunctionCall{"trigger_counter"},
                            {datamodel::ParameterValue{
                                 update_counter,
                                 datamodel::ParameterValue::InternalValue{"", update_counter}},
                             datamodel::ParameterValue{
                                 "modulo", datamodel::ParameterValue::ConstValue{*parameter}}}};
                }
                else {
                    throw Error("Mapping10::createFunctionCall",
                                {target_name, function_attribute},
                                "function 'trigger_counter' has no positive "
                                "integer value as parameter");
                }
            }
            else {
                need_functions.trigger_counter_function = true;
                return {datamodel::Assignment::FunctionCall{"trigger_counter"},
                        {datamodel::ParameterValue{
                            update_counter,
                            datamodel::ParameterValue::InternalValue{"", update_counter}}}};
            }
        }
        else if (function_attribute.find("received") != std::string::npos) {
            const auto parameter = parseFunctionParameter(function_attribute);
            if (parameter) {
                need_functions.was_received_function = true;
                return {datamodel::Assignment::FunctionCall{"was_received"},
                        {datamodel::ParameterValue{
                            update_counter,
                            datamodel::ParameterValue::InternalValue{*parameter, update_counter}}}};
            }
            else {
                throw Error("Mapping10::createFunctionCall",
                            {target_name, function_attribute},
                            "function 'received' has no source name set as parameter");
            }
        }
        else {
            throw Error("Mapping10::createFunctionCall",
                        {target_name, function_attribute},
                        "function=" + function_attribute + " is unknown");
        }
    }

    static datamodel::Assignment createAssignment(const DomNodeType& dom_node,
                                                  const std::string& target_name,
                                                  NeedFunctions& need_functions)
    {
        const auto to_name = getAttributeMandatory<std::string>(dom_node, "to");
        const auto constant = getAttribute<std::string>(dom_node, "constant");
        if (constant) {
            return datamodel::Assignment(*to_name, datamodel::Assignment::ConstValue{*constant});
        }
        else {
            const auto from = getAttribute<std::string>(dom_node, "from");
            if (from) {
                const auto transformation = getAttribute<std::string>(dom_node, "transformation");
                if (transformation) {
                    return datamodel::Assignment(
                        *to_name,
                        datamodel::Assignment::FunctionCall{*transformation},
                        {datamodel::ParameterValue{"value", getAsSourceValue(from)}});
                }
                else {
                    return datamodel::Assignment(*to_name, getAsSourceValue(from));
                }
            }
            else {
                const auto function = getAttribute<std::string>(dom_node, "function");
                if (function) {
                    const auto function_call_values =
                        createFunctionCall(target_name, *function, need_functions);
                    return datamodel::Assignment(
                        *to_name, function_call_values.first, function_call_values.second);
                }
            }
        }
        throw Error("Mapping10::createAssignment",
                    {dom_node.getName()},
                    "assignment has no valid attribute (constant function or from) set");
    }

    static datamodel::Trigger createPeriodTrigger(const DomNodeType& dom_node)
    {
        const auto time_value =
            getAttributeMandatory<std::string>(dom_node, "period", " with type=periodic");
        const auto unit_value =
            getAttributeMandatory<std::string>(dom_node, "unit", " with type=periodic");
        return datamodel::Trigger(datamodel::Trigger::Period{*time_value, *unit_value});
    }

    static datamodel::Trigger createDataTrigger(const DomNodeType& dom_node)
    {
        const auto variable_name =
            getAttributeMandatory<std::string>(dom_node, "variable", " with type=data");
        const auto operator_name =
            getAttributeMandatory<std::string>(dom_node, "operator", " with type=data");
        const auto value = getAttributeMandatory<std::string>(dom_node, "value", " with type=data");
        const auto source_value = getAsSourceValue(*variable_name);
        return datamodel::Trigger(datamodel::Trigger::Data{
            source_value.name, source_value.value_name, *operator_name, *value});
    }

    static datamodel::Trigger createSourceTrigger(const DomNodeType& dom_node)
    {
        const auto source_name =
            getAttributeMandatory<std::string>(dom_node, "variable", " with type=signal");
        return datamodel::Trigger(datamodel::Trigger::Source{*source_name});
    }

    static datamodel::Trigger createTrigger(const DomNodeType& dom_node)
    {
        const auto trigger_type = getAttributeMandatory<std::string>(dom_node, "type");
        if (*trigger_type == "signal") {
            return createSourceTrigger(dom_node);
        }
        else if (*trigger_type == "data") {
            return createDataTrigger(dom_node);
        }
        else if (*trigger_type == "periodic") {
            return createPeriodTrigger(dom_node);
        }
        throw Error("Mapping10::createTrigger",
                    {dom_node.getName()},
                    "trigger type='" + *trigger_type + "' is unsupported in mapping version 1.0");
    }

    static datamodel::Target createTarget(const DomNodeType& dom_node, NeedFunctions& need_functions)
    {
        const auto name = getAttributeMandatory<std::string>(dom_node, "name");
        // We have a type attribute in 1.0
        const auto ddl_type = getAttributeMandatory<std::string>(dom_node, "type");
 
        datamodel::Target target(*name, "", {{"type", *ddl_type}});
 
        std::list<DomNodeType> assignments;
        if (dom_node.findNodes("assignment", assignments)) {
            for (const auto& current_assignment: assignments) {
                target.getAssignments().emplace(
                    createAssignment(current_assignment, *name, need_functions));
            }
        }
        std::list<DomNodeType> triggers;
        if (dom_node.findNodes("trigger", triggers)) {
            for (const auto& current_trigger: triggers) {
                target.getTriggers().emplace(createTrigger(current_trigger));
            }
        }
        return target;
    }

    static void setOptionalProperty(const DomNodeType& dom_node,
                                    const std::string& property_name,
                                    datamodel::Function& module_instance)
    {
        const auto property_value =
            xml_base_type::template getAttribute<std::string>(dom_node, property_name.c_str());
        if (property_value) {
            module_instance.getProperties().emplace({property_name, *property_value});
        }
    }

    static void setEnumTableProperty(const DomNodeType& dom_node, datamodel::Function& module_inst)
    {
        std::stringstream value;
        std::list<DomNodeType> conversion_nodes;
        dom_node.findNodes("conversion", conversion_nodes);
        bool first = true;
        for (const auto& current: conversion_nodes) {
            if (first) {
                first = false;
            }
            else {
                value << std::endl;
            }
            const auto from = getAttributeMandatory<std::string>(
                current, "from", " within enum_table " + module_inst.getName());
            const auto to = getAttributeMandatory<std::string>(
                current, "to", " within enum_table " + module_inst.getName());
            value << *from << "=" << *to;
        }
        module_inst.getProperties().emplace({"table", value.str()});
    }

    static datamodel::Function createFunctionFromTransformation(const DomNodeType& dom_node)
    {
        const auto name = getAttributeMandatory<std::string>(dom_node, "name");
        const auto type = dom_node.getName();
        if (type == "polynomial") {
            datamodel::Function module_instance(*name, type);
            setOptionalProperty(dom_node, "a", module_instance);
            setOptionalProperty(dom_node, "b", module_instance);
            setOptionalProperty(dom_node, "c", module_instance);
            setOptionalProperty(dom_node, "d", module_instance);
            setOptionalProperty(dom_node, "e", module_instance);
            return module_instance;
        }
        else if (type == "enum_table") {
            datamodel::Function module_instance(*name, "ddl_enum_table");
            setOptionalProperty(dom_node, "from", module_instance);
            setOptionalProperty(dom_node, "to", module_instance);
            setOptionalProperty(dom_node, "default", module_instance);
            setEnumTableProperty(dom_node, module_instance);
            return module_instance;
        }
        throw Error("Mapping10::createModuleFromTransformation",
                    {type},
                    "unsupported transformation tag '" + type + "'");
    }

    static datamodel::MappingConfiguration createConfiguration(const DomNodeType& dom_node,
                                                               const datamodel::Header& header)
    {
        // we use the version given, but if header exists we use the headers version
        datamodel::MappingConfiguration new_config;
        new_config.setHeader(header);
 
        // read sources
        std::list<DomNodeType> source_nodes;
        if (dom_node.findNodes("//sources/source", source_nodes)) {
            for (const auto& current_source_node: source_nodes) {
                new_config.getSources().emplace(createSource(current_source_node));
            }
        }
        NeedFunctions need_functions;
        std::list<DomNodeType> target_nodes;
        if (dom_node.findNodes("//targets/target", target_nodes)) {
            for (const auto& current_target_node: target_nodes) {
                new_config.getTargets().emplace(createTarget(current_target_node, need_functions));
            }
        }
 
        auto& functions = new_config.getFunctions();
        std::list<DomNodeType> transformation_nodes;
        if (dom_node.findNodes("//transformations/*", transformation_nodes)) {
            for (const auto& current_transformation_node: transformation_nodes) {
                functions.emplace(createFunctionFromTransformation(current_transformation_node));
            }
        }
 
        if (need_functions.simulation_time_function) {
            if (!functions.contains("simulation_time")) {
                functions.emplace(datamodel::Function("simulation_time", "simulation_time"));
            }
        }
        if (need_functions.was_received_function) {
            if (!functions.contains("was_received")) {
                functions.emplace(datamodel::Function("was_received", "was_received"));
            }
        }
        if (need_functions.trigger_counter_function) {
            if (!functions.contains("trigger_counter")) {
                functions.emplace(datamodel::Function("trigger_counter", "trigger_counter"));
            }
        }
        return new_config;
    }
};
 
} // namespace mapping
} // namespace ddl
 
#endif // MAPPING_CONFIGURATION_FROM_XML_10_H_INCLUDED