datamodel_xml_configurationfromxml.h

Go to the documentation of this file.

 
#ifndef MAPPING_CONFIGURATION_FROM_XML_FACTORY_H_INCLUDED
#define MAPPING_CONFIGURATION_FROM_XML_FACTORY_H_INCLUDED
 
#include <ddl/mapping/datamodel/datamodel_xml_configurationfromxml_10.h>
 
namespace ddl {
namespace mapping {
template <typename DomNodeType>
struct MappingConfigurationFromXMLFactory {
    using xml_base_type = MappingConfigurationFromXMLFactoryBase<DomNodeType>;
    using xml_mapping10_type = MappingConfigurationFromXMLFactory10<DomNodeType>;
    static constexpr auto mapping_reading_version = "Mapping20::";

    template <typename T>
    static utility::Optional<T> getAttributeMandatory(const DomNodeType& dom_node,
                                                      const std::string& attribute_name)
    {
        return xml_base_type::template getAttribute<std::string>(
            dom_node,
            attribute_name,
            {},
            true,
            dom_node.getName() + " 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);
    }

    template <typename T>
    static utility::Optional<T> getDataSubNodeMandatory(const DomNodeType& dom_node,
                                                        const std::string& tag_name,
                                                        const std::string& additional_info = {})
    {
        return xml_base_type::template getDataSubNode<std::string>(
            dom_node,
            tag_name,
            {},
            true,
            dom_node.getName() + additional_info + " tag has no mandatory <" + tag_name + "/> tag",
            mapping_reading_version);
    }

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

    static datamodel::Header createHeader(const DomNodeType& dom_node, const Version& version)
    {
        datamodel::Header created_header(version);
        auto file_mapping_version = getDataSubNode<std::string>(dom_node, "language_version");
        if (file_mapping_version) {
            Version version_to_set = VersionConversion::fromString(*file_mapping_version);
            created_header.setMappingVersion(version_to_set);
        }
 
        auto author = getDataSubNode<std::string>(dom_node, "author");
        if (author) {
            created_header.setAuthor(author);
        }
        auto date_crea = getDataSubNode<std::string>(dom_node, "date_creation");
        if (date_crea) {
            created_header.setDateCreation(date_crea);
        }
        auto date_cha = getDataSubNode<std::string>(dom_node, "date_change");
        if (date_cha) {
            created_header.setDateChange(date_cha);
        }
        auto description = getDataSubNode<std::string>(dom_node, "description");
        if (description) {
            created_header.setDescription(description);
        }
        return created_header;
    }

    template <typename PropertiesType>
    static void setDataOrSubNodesAsProperty(const DomNodeType& dom_node, PropertiesType& properties)
    {
        const auto name = getAttributeMandatory<std::string>(dom_node, "name");
        xml_base_type::template setDataOrSubNodesAsProperty<PropertiesType>(
            dom_node, *name, properties);
    }

    static datamodel::Source createSource(const DomNodeType& dom_node)
    {
        const auto name = getAttributeMandatory<std::string>(dom_node, "name");
        const auto source_type = getAttribute<std::string>(dom_node, "source_type");
 
        datamodel::Source source(*name, *source_type);
        // we have have properties
        std::list<DomNodeType> properties;
        if (dom_node.findNodes("properties//property", properties)) {
            for (const auto& current_property: properties) {
                setDataOrSubNodesAsProperty(current_property, source.getProperties());
            }
        }
        return source;
    }

    static datamodel::ParameterValue createParameterValue(const DomNodeType& dom_node)
    {
        const auto name = getAttributeMandatory<std::string>(dom_node, "name");
        const auto type = getAttributeMandatory<std::string>(dom_node, "type");
        if (*type == "source") {
            const auto source_name = getDataSubNodeMandatory<std::string>(
                dom_node, "source_name", " with type='source' ");
            const auto value_name = getDataSubNode<std::string>(dom_node, "value_name");
            return {name, datamodel::ParameterValue::SourceValue{*source_name, *value_name}};
        }
        else if (*type == "const") {
            const auto value =
                getDataSubNodeMandatory<std::string>(dom_node, "value", " with type='const' ");
            return {name, datamodel::ParameterValue::ConstValue{*value}};
        }
        else if (*type == "internal") {
            const auto internal_name = getDataSubNode<std::string>(dom_node, "internal_name");
            const auto value_name = getDataSubNodeMandatory<std::string>(
                dom_node, "value_name", " with type='internal'");
            return {name, datamodel::ParameterValue::InternalValue{*internal_name, *value_name}};
        }
        else {
            throw Error("createParameterValue", {*name, *type}, "unsupported type for assignment");
        }
    }

    static datamodel::Assignment createAssignment(const DomNodeType& dom_node)
    {
        const auto to_name = getDataSubNodeMandatory<std::string>(dom_node, "to");
        const auto assignment_type = getAttributeMandatory<std::string>(dom_node, "type");
 
        if (*assignment_type == "source") {
            const auto source_name =
                getDataSubNodeMandatory<std::string>(dom_node, "source_name", " with type=source");
            const auto value_name = getDataSubNode<std::string>(dom_node, "value_name");
            return datamodel::Assignment(
                *to_name, datamodel::Assignment::SourceValue{*source_name, *value_name});
        }
        else if (*assignment_type == "const") {
            const auto value =
                getDataSubNodeMandatory<std::string>(dom_node, "value", " with type=const");
            return datamodel::Assignment(*to_name, datamodel::Assignment::ConstValue{*value});
        }
        else if (*assignment_type == "call") {
            const auto function_name =
                getDataSubNodeMandatory<std::string>(dom_node, "function", " with type=call");
 
            datamodel::Assignment assignment(
                *to_name, datamodel::Assignment::FunctionCall{*function_name});
 
            std::list<DomNodeType> parameter_values;
            dom_node.findNodes("parameter_value", parameter_values);
            for (const auto& current_param_node: parameter_values) {
                assignment.getParameterValues().emplace(createParameterValue(current_param_node));
            }
            return assignment;
        }
        throw Error("Mapping20::createAssignment",
                    {dom_node.getName()},
                    "assignment type='" + *assignment_type + "' is unsupported");
    }

    static datamodel::Trigger createPeriodTrigger(const DomNodeType& dom_node)
    {
        const auto time_value =
            getDataSubNodeMandatory<std::string>(dom_node, "time", " with type=periodic");
        const auto unit_value =
            getDataSubNodeMandatory<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 source =
            getDataSubNodeMandatory<std::string>(dom_node, "source_name", " with type=data");
        const auto value_name =
            getDataSubNodeMandatory<std::string>(dom_node, "value_name", " with type=data");
        const auto operator_name =
            getDataSubNodeMandatory<std::string>(dom_node, "operator", " with type=data");
        const auto value =
            getDataSubNodeMandatory<std::string>(dom_node, "value", " with type=data");
        return datamodel::Trigger(
            datamodel::Trigger::Data{*source, *value_name, *operator_name, *value});
    }

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

    static datamodel::Trigger createTrigger(const DomNodeType& dom_node, const Version& version)
    {
        const auto trigger_type = getAttributeMandatory<std::string>(dom_node, "type");
        const auto parse_trigger_node = [&]() {
            if (*trigger_type == "source") {
                return createSourceTrigger(dom_node);
            }
            else if (*trigger_type == "data") {
                return createDataTrigger(dom_node);
            }
            else if (*trigger_type == "periodic") {
                return createPeriodTrigger(dom_node);
            }
            else {
                throw Error("Mapping20::createTrigger",
                            {dom_node.getName()},
                            "trigger type='" + *trigger_type + "' is unsupported");
            }
        };
        datamodel::Trigger created_trigger = parse_trigger_node();
        if (version > Version(2, 0)) {
            const auto time_strategy = getDataSubNode<std::string>(dom_node, "time_strategy");
            if (time_strategy) {
                created_trigger.setTimeStrategy(*time_strategy);
            }
        }
        return created_trigger;
    }

    static datamodel::Trigger createTrigger(const DomNodeType& dom_node)
    {
        return createTrigger(dom_node, Version(2, 0));
    }

    static datamodel::Target createTarget(const DomNodeType& dom_node, const Version& version)
    {
        const auto name = getAttributeMandatory<std::string>(dom_node, "name");
        const auto target_type =
            xml_base_type::template getAttribute<std::string>(dom_node, "target_type");
 
        datamodel::Target target(*name, *target_type);
 
        // we have properties
        std::list<DomNodeType> properties;
        if (dom_node.findNodes("properties//property", properties)) {
            for (const auto& current_property: properties) {
                setDataOrSubNodesAsProperty(current_property, target.getProperties());
            }
        }
 
        std::list<DomNodeType> assignments;
        if (dom_node.findNodes("assignments//assignment", assignments)) {
            for (const auto& current_assignment: assignments) {
                target.getAssignments().emplace(createAssignment(current_assignment));
            }
        }
        std::list<DomNodeType> triggers;
        if (dom_node.findNodes("triggers//trigger", triggers)) {
            for (const auto& current_trigger: triggers) {
                target.getTriggers().emplace(createTrigger(current_trigger, version));
            }
        }
        return target;
    }

    static datamodel::Target createTarget(const DomNodeType& dom_node)
    {
        return createTarget(dom_node, Version(2, 0));
    }

    static datamodel::Function createFunction(const DomNodeType& dom_node)
    {
        const auto name = getAttributeMandatory<std::string>(dom_node, "name");
        const auto module_type = getAttributeMandatory<std::string>(dom_node, "function_type");
 
        datamodel::Function module_instance(*name, *module_type);
 
        // we have properties
        std::list<DomNodeType> properties;
        if (dom_node.findNodes("properties//property", properties)) {
            for (const auto& current_property: properties) {
                setDataOrSubNodesAsProperty(current_property, module_instance.getProperties());
            }
        }
        return module_instance;
    }

    static datamodel::MappingConfiguration createConfiguration(
        const DomNodeType& dom_node, const Version& mapping_version = Version::getLatestVersion())
    {
        DomNodeType header_element;
        datamodel::Header header(mapping_version);
        if (dom_node.findNode("header", header_element)) {
            header = createHeader(header_element, mapping_version);
        }
        const auto current_version = header.getMappingVersion();
        if (current_version < Version(2, 0)) {
            return xml_mapping10_type::createConfiguration(dom_node, header);
        }
        else {
            datamodel::MappingConfiguration new_config(current_version);
            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));
                }
            }
            // read targets
            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, current_version));
                }
            }
            // read functions
            std::list<DomNodeType> function_nodes;
            if (dom_node.findNodes("//functions/function", function_nodes)) {
                for (const auto& current_func_node: function_nodes) {
                    new_config.getFunctions().emplace(createFunction(current_func_node));
                }
            }
            return new_config;
        }
    }
};
 
} // namespace mapping
} // namespace ddl
 
#endif // MAPPING_CONFIGURATION_FROM_XML_FACTORY_H_INCLUDED