datamodel_xml_configurationfromxml_base.h

Go to the documentation of this file.

 
#ifndef MAPPING_CONFIGURATION_FROM_XML_BASE_INCLUDED
#define MAPPING_CONFIGURATION_FROM_XML_BASE_INCLUDED
 
#include <ddl/utilities/access_optional.h>
#include <ddl/utilities/ddl_error.h>
#include <ddl/utilities/string_check.h>
 
#include <map>
#include <sstream>
 
namespace ddl {
namespace mapping {
template <typename DomNodeType>
struct MappingConfigurationFromXMLFactoryBase {
    template <typename T>
    static utility::Optional<T> getAttribute(const DomNodeType& dom_node,
                                             const std::string& attribute_name,
                                             const utility::Optional<T>& default_value = {},
                                             bool is_mandatory = false,
                                             const std::string& parse_error_message = {},
                                             const std::string& mapping_reading_version = {})
    {
        auto value = dom_node.getAttribute(attribute_name);
        if (value.empty()) {
            if (is_mandatory) {
                throw utility::Error(std::string(mapping_reading_version) + "::getAttribute",
                                     {"...", attribute_name},
                                     parse_error_message);
            }
            return default_value;
        }
        else {
            return utility::toType(value, default_value);
        }
    }

    template <typename T>
    static utility::Optional<T> getData(const DomNodeType& dom_node,
                                        const utility::Optional<T>& default_value = {},
                                        bool is_mandatory = false,
                                        const std::string& parse_error_message = "",
                                        const std::string& mapping_reading_version = {})
    {
        const std::string value = dom_node.getData();
        if (value.empty()) {
            if (is_mandatory) {
                throw utility::Error(std::string(mapping_reading_version) + "::getData ",
                                     {dom_node.getName(), "..."},
                                     parse_error_message);
            }
            return default_value;
        }
        else {
            return utility::toType(value, default_value);
        }
    }

    template <typename T>
    static utility::Optional<T> getDataSubNode(const DomNodeType& dom_node,
                                               const std::string& sub_node_name,
                                               const utility::Optional<T>& default_value = {},
                                               bool is_mandatory = false,
                                               const std::string& parse_error_message = {},
                                               const std::string& mapping_reading_version = {})
    {
        DomNodeType sub_node;
        std::string value = {};
        if (dom_node.findNode(sub_node_name, sub_node)) {
            return getData<T>(sub_node, default_value, is_mandatory, parse_error_message);
        }
        else {
            if (is_mandatory) {
                throw Error(std::string(mapping_reading_version) + "getDataSubNode",
                            {dom_node.getName(), sub_node_name},
                            parse_error_message);
            }
            return default_value;
        }
    }

    static void attributesToString(const std::map<std::string, std::string>& attributes,
                                   std::stringstream& property_stream)
    {
        if (!attributes.empty()) {
            for (const auto& current: attributes) {
                property_stream << " " << current.first << "=\"" << current.second << "\"";
            }
        }
    }

    static void nodeToString(const DomNodeType& dom_node,
                             std::stringstream& property_stream,
                             size_t level = 0)
    {
        const std::string tab(level, ' ');
        const auto data = dom_node.getData();
        if (!data.empty() && level != 0) {
            property_stream << tab << "<" << dom_node.getName();
            attributesToString(dom_node.getAttributes(), property_stream);
            property_stream << ">";
            property_stream << data;
            property_stream << tab << "</" << dom_node.getName() << ">" << std::endl;
        }
        else {
            const auto nodes = dom_node.getChildren();
            if (nodes.empty() && level != 0) {
                property_stream << tab << "<" << dom_node.getName();
                attributesToString(dom_node.getAttributes(), property_stream);
                property_stream << "/>" << std::endl;
            }
            else {
                if (level != 0) {
                    property_stream << tab << "<" << dom_node.getName();
                    attributesToString(dom_node.getAttributes(), property_stream);
                    property_stream << ">" << std::endl;
                }
                for (const auto& current: nodes) {
                    nodeToString(current, property_stream, level + 1);
                }
                if (level != 0) {
                    property_stream << tab << "</" << dom_node.getName() << ">" << std::endl;
                }
            }
        }
    }

    template <typename PropertiesType>
    static void setDataOrSubNodesAsProperty(const DomNodeType& dom_node,
                                            const std::string& property_name,
                                            PropertiesType& properties_target)
    {
        auto data = dom_node.getData();
        if (!data.empty()) {
            utility::replaceInString(data, "&lt;", "<");
            utility::replaceInString(data, "&gt;", ">");
            properties_target.emplace({property_name, data});
        }
        else {
            std::stringstream prop_stream;
            nodeToString(dom_node, prop_stream);
            properties_target.emplace({property_name, prop_stream.str()});
        }
    }
};
 
} // namespace mapping
} // namespace ddl
 
#endif // MAPPING_CONFIGURATION_FROM_XML_BASE_INCLUDED