datamodel_xml_configurationtoxml.h

Go to the documentation of this file.

 
#ifndef MAPPING_CONFIGURATION_TO_XML_FACTORY_H_INCLUDED
#define MAPPING_CONFIGURATION_TO_XML_FACTORY_H_INCLUDED
 
#include <ddl/mapping/datamodel/datamodel_configuration.h>
#include <ddl/mapping/datamodel/datamodel_xml_configurationtoxml_10.h>
#include <ddl/mapping/datamodel/datamodel_xml_configurationtoxml_base.h>
 
#include <stdexcept>
#include <string>
 
namespace ddl {
namespace mapping {

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

    static void createNode(DomNodeType& parent_node, const datamodel::Header& header)
    {
        DomNodeType sub_node = parent_node.createChild("header");
        xml_base_type::setSubNodeData(
            sub_node, "language_version", VersionConversion::toString(header.getMappingVersion()));
        xml_base_type::setSubNodeData(sub_node, "author", header.getAuthor());
        xml_base_type::setSubNodeData(sub_node, "date_creation", header.getDateCreation());
        xml_base_type::setSubNodeData(sub_node, "date_change", header.getDateChange());
        xml_base_type::setSubNodeData(sub_node, "description", header.getDescription());
    }

    static void createNode(DomNodeType& parent_node, const datamodel::Property& property_value)
    {
        DomNodeType property_node = parent_node.createChild("property");
        property_node.setAttribute("name", property_value.getName());
        property_node.setData(property_value.getValue());
    }

    template <typename PropertiesType>
    static void createProperties(DomNodeType& parent_node, const PropertiesType& properties)
    {
        DomNodeType properties_node = parent_node.createChild("properties");
        for (const auto& current_property: properties) {
            DomNodeType property_node = properties_node.createChild("property");
            property_node.setAttribute("name", current_property.second->getName());
            property_node.setData(current_property.second->getValue());
        }
    }

    static void createNode(DomNodeType& parent_node, const datamodel::Source& source)
    {
        DomNodeType source_node = parent_node.createChild("source");
        source_node.setAttribute("name", source.getName());
        xml_base_type::template setOptionalAttribute(source_node, "source_type", source.getType());
        createProperties(source_node, source.getProperties());
    }

    static void createNode(DomNodeType& parent_node,
                           const datamodel::ParameterValue& parameter_value)
    {
        DomNodeType param_value_node = parent_node.createChild("parameter_value");
        param_value_node.setAttribute("name", parameter_value.getName());
        if (parameter_value.getType() == datamodel::ParameterValue::Type::const_value) {
            param_value_node.setAttribute("type", "const");
            xml_base_type::setSubNodeData(
                param_value_node, "value", parameter_value.getConstValue().value);
        }
        else if (parameter_value.getType() == datamodel::ParameterValue::Type::source_value) {
            param_value_node.setAttribute("type", "source");
            const auto source_value = parameter_value.getSourceValue();
            xml_base_type::setSubNodeData(param_value_node, "source_name", source_value.name);
            xml_base_type::setOptionalSubNodeData(
                param_value_node, "value_name", source_value.value_name);
        }
        else if (parameter_value.getType() == datamodel::ParameterValue::Type::internal_value) {
            param_value_node.setAttribute("type", "internal");
            const auto internal_value = parameter_value.getInternalValue();
            xml_base_type::setOptionalSubNodeData(
                param_value_node, "internal_name", internal_value.name);
            xml_base_type::setSubNodeData(
                param_value_node, "value_name", internal_value.value_name);
        }
    }

    static void createNode(DomNodeType& parent_node, const datamodel::Assignment& assignment)
    {
        DomNodeType assignment_node = parent_node.createChild("assignment");
        xml_base_type::setSubNodeData(assignment_node, "to", assignment.getTo());
        if (assignment.getType() == datamodel::Assignment::Type::const_value) {
            assignment_node.setAttribute("type", "const");
            xml_base_type::setSubNodeData(
                assignment_node, "value", assignment.getConstValue().value);
        }
        else if (assignment.getType() == datamodel::Assignment::Type::source_value) {
            assignment_node.setAttribute("type", "source");
            const auto source_value = assignment.getSourceValue();
            xml_base_type::setSubNodeData(assignment_node, "source_name", source_value.name);
            xml_base_type::setOptionalSubNodeData(
                assignment_node, "value_name", source_value.value_name);
        }
        else if (assignment.getType() == datamodel::Assignment::Type::function_call) {
            assignment_node.setAttribute("type", "call");
            const auto module_call = assignment.getFunctionCall();
            xml_base_type::setSubNodeData(assignment_node, "function", module_call.function_name);
            for (const auto& current_param_value: assignment.getParameterValues()) {
                createNode(assignment_node, *current_param_value);
            }
        }
        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.getType() == datamodel::Trigger::Type::source) {
            trigger_node.setAttribute("type", "source");
            xml_base_type::setSubNodeData(
                trigger_node, "source_name", trigger.getSource().source_name);
        }
        else if (trigger.getType() == datamodel::Trigger::Type::period) {
            trigger_node.setAttribute("type", "periodic");
            const auto period = trigger.getPeriod();
            xml_base_type::setSubNodeData(trigger_node, "time", period.time);
            xml_base_type::setSubNodeData(trigger_node, "unit", period.unit);
        }
        else if (trigger.getType() == datamodel::Trigger::Type::data) {
            trigger_node.setAttribute("type", "data");
            const auto data = trigger.getData();
            xml_base_type::setSubNodeData(trigger_node, "source_name", data.source_name);
            xml_base_type::setSubNodeData(trigger_node, "value_name", data.source_value_name);
            xml_base_type::setSubNodeData(trigger_node, "operator", data.operation);
            xml_base_type::setSubNodeData(trigger_node, "value", data.value);
        }
        else {
            throw Error("createNode", {"trigger"}, "invalid trigger type");
        }
        const auto time_strategy = trigger.getTimeStrategy();
        if (!time_strategy.empty()) {
            xml_base_type::setSubNodeData(trigger_node, "time_strategy", time_strategy);
        }
    }

    static void createNode(DomNodeType& parent_node, const datamodel::Target& target)
    {
        DomNodeType target_node = parent_node.createChild("target");
        target_node.setAttribute("name", target.getName());
        xml_base_type::template setOptionalAttribute(target_node, "target_type", target.getType());
 
        // Properties
        createProperties(target_node, target.getProperties());
 
        // Assignments
        DomNodeType assignments_node = target_node.createChild("assignments");
        for (const auto& current_assignment: target.getAssignments()) {
            createNode(assignments_node, *(current_assignment));
        }
 
        // Triggers
        DomNodeType triggers_node = target_node.createChild("triggers");
        for (const auto& current_trigger: target.getTriggers()) {
            createNode(triggers_node, *(current_trigger));
        }
    }

    static void createNode(DomNodeType& parent_node, const datamodel::Function& function_inst)
    {
        DomNodeType function_node = parent_node.createChild("function");
        function_node.setAttribute("name", function_inst.getName());
        xml_base_type::template setOptionalAttribute(
            function_node, "function_type", function_inst.getType());
        createProperties(function_node, function_inst.getProperties());
    }

    static void createNode(DomNodeType& parent_node, const datamodel::MappingConfiguration& config)
    {
        createNode(parent_node, *(config.getHeader()));
 
        if (config.getVersion() < Version(2, 0)) {
            xml_mapping10_type::createNode(parent_node, config);
        }
        else {
            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();
            for (const auto& target: targets) {
                createNode(targets_node, *(target.second));
            }
 
            DomNodeType functions_node = parent_node.createChild("functions");
            // write modules
            const auto& functions = config.getFunctions();
            for (const auto& func_inst: functions) {
                createNode(functions_node, *(func_inst.second));
            }
        }
    }
};
} // namespace mapping
} // namespace ddl
 
#endif // MAPPING_CONFIGURATION_TO_XML_FACTORY_H_INCLUDED