xml_ddfromxml_factory.h

Go to the documentation of this file.

 
#ifndef DD_DD_FROM_XML_FACTORY_H_INCLUDED
#define DD_DD_FROM_XML_FACTORY_H_INCLUDED
 
#include <ddl/dd/datamodel/datamodel_datadefinition.h>
#include <ddl/dd/datamodel/xml_literals.h>
#include <ddl/dd/dd_predefined_datatypes.h>
#include <ddl/utilities/access_optional.h>
#include <ddl/utilities/ddl_error.h>
#include <ddl/utilities/std_to_string.h>
#include <ddl/utilities/string_check.h>
 
#include <list>
#include <regex>
#include <stdexcept>
#include <string>
#include <string_view>
 
namespace ddl {
namespace dd {
 
namespace detail {
template <typename T>
T toType(std::string from_string, T default_value) noexcept;
template <typename T>
T toRequiredType(std::string from_string);
 
template <>
inline int toType<int>(std::string from_string, int default_value) noexcept
{
    try {
        int i_converted = std::stoi(std::move(from_string));
        return i_converted;
    }
    catch (const std::invalid_argument&) {
        return default_value;
    }
    catch (const std::exception&) {
        return default_value;
    }
}
 
template <>
inline int toRequiredType<int>(std::string from_string)
{
    int i_converted = std::stoi(std::move(from_string));
    return i_converted;
}
 
template <>
inline size_t toType<size_t>(std::string from_string, size_t default_value) noexcept
{
    try {
        int size_converted = std::stoi(std::move(from_string));
        if (size_converted < 0) {
            // this is if we set i.e. the bytepos to -1 if it is after a dynamic array
            return default_value;
        }
        else {
            return size_converted;
        }
    }
    catch (const std::invalid_argument&) {
        return default_value;
    }
    catch (const std::exception&) {
        return default_value;
    }
}
template <>
inline size_t toRequiredType<size_t>(std::string from_string)
{
    int size_converted = std::stoi(std::move(from_string));
    if (size_converted < 0) {
        // this is if we set i.e. the bytepos to -1 if it is after a dynamic array
        return 0;
    }
    else {
        return size_converted;
    }
}
template <>
inline std::string toType<std::string>(std::string from_string, std::string default_value) noexcept
{
    if (from_string.empty()) {
        return std::move(default_value);
    }
    else {
        return std::move(from_string);
    }
}
template <>
inline std::string toRequiredType<std::string>(std::string from_string)
{
    using namespace std::string_literals;
    if (from_string.empty()) {
        throw std::invalid_argument("Empty string"s);
    }
    else {
        return std::move(from_string);
    }
}
} // namespace detail

template <typename DOM_NODE_TYPE>
struct DDFromXMLFactory {
    static bool isInteger(const std::string& string_to_check) noexcept
    {
        return utility::isInteger(string_to_check);
    }
 
    struct Mandatory final {};
    struct AsOptional final {};

    template <typename T>
    static utility::Optional<T> getAttribute(const DOM_NODE_TYPE& dom_node,
                                             const std::string& attribute_name,
                                             AsOptional /*tag*/)
    {
        using namespace std::string_literals;
        auto value = dom_node.getAttribute(attribute_name);
        if (value.empty()) {
            return {};
        }
        else {
            try {
                return detail::toRequiredType<T>(std::move(value));
            }
            catch (const std::exception& e) {
                throw Error("DDFromXMLFactory::getAttribute"s,
                            {"..."s, attribute_name},
                            dom_node.getName() + " has invalid data in "s + attribute_name +
                                " attribute: "s + e.what());
            }
        }
    }
 
    template <typename T>
    static T getAttribute(const DOM_NODE_TYPE& dom_node,
                          const std::string& attribute_name,
                          T default_value) noexcept
    {
        using namespace std::string_literals;
        auto value = dom_node.getAttribute(attribute_name);
        if (value.empty()) {
            return std::move(default_value);
        }
        else {
            return detail::toType<T>(std::move(value), std::move(default_value));
        }
    }
 
    template <typename T>
    static T getAttribute(const DOM_NODE_TYPE& dom_node,
                          const std::string& attribute_name,
                          Mandatory /*tag*/)
    {
        using namespace std::string_literals;
        auto value = dom_node.getAttribute(attribute_name);
        if (value.empty()) {
            throw Error("DDFromXMLFactory::getAttribute"s,
                        {"..."s, attribute_name},
                        dom_node.getName() + " has no mandatory "s + attribute_name +
                            " attribute."s);
        }
        else {
            try {
                return detail::toRequiredType<T>(std::move(value));
            }
            catch (const std::exception& e) {
                throw Error("DDFromXMLFactory::getAttribute"s,
                            {"..."s, attribute_name},
                            dom_node.getName() + " has invalid data in "s + attribute_name +
                                " attribute: "s + e.what());
            }
        }
    }

    template <typename T>
    static utility::Optional<T> getData(const DOM_NODE_TYPE& dom_node,
                                        const std::string& sub_node_name,
                                        AsOptional /*tag*/)
    {
        using namespace std::string_literals;
        DOM_NODE_TYPE sub_node;
        std::string value = {};
        if (dom_node.findNode(sub_node_name, sub_node)) {
            value = sub_node.getData();
        }
        if (value.empty()) {
            return {};
        }
        else {
            try {
                return detail::toRequiredType<T>(std::move(value));
            }
            catch (const std::exception& e) {
                throw Error("DDFromXMLFactory::getData"s,
                            {"..."s, sub_node_name},
                            dom_node.getName() + " has invalid data in '"s + sub_node_name +
                                "' child:"s + e.what());
            }
        }
    }
 
    template <typename T>
    static T getData(const DOM_NODE_TYPE& dom_node,
                     const std::string& sub_node_name,
                     T default_value) noexcept
    {
        using namespace std::string_literals;
        DOM_NODE_TYPE sub_node;
        std::string value = {};
        if (dom_node.findNode(sub_node_name, sub_node)) {
            value = sub_node.getData();
        }
        if (value.empty()) {
            return std::move(default_value);
        }
        else {
            return detail::toType<T>(std::move(value), std::move(default_value));
        }
    }
    template <typename T>
    static T getData(const DOM_NODE_TYPE& dom_node,
                     const std::string& sub_node_name,
                     Mandatory /*tag*/)
    {
        using namespace std::string_literals;
        DOM_NODE_TYPE sub_node;
        std::string value = {};
        if (dom_node.findNode(sub_node_name, sub_node)) {
            value = sub_node.getData();
        }
        if (value.empty()) {
            throw Error("DDFromXMLFactory::getData"s,
                        {"..."s, sub_node_name},
                        dom_node.getName() + " has no mandatory '"s + sub_node_name + "' child."s);
        }
        else {
            try {
                return detail::toRequiredType<T>(std::move(value));
            }
            catch (const std::exception& e) {
                throw Error("DDFromXMLFactory::getData"s,
                            {"..."s, sub_node_name},
                            dom_node.getName() + " has invalid data in '"s + sub_node_name +
                                "' child: "s + e.what());
            }
        }
    }

    static datamodel::Header::ExtDeclaration createHeaderExtDeclaration(
        const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        using namespace std::string_literals;
        auto key_attrib = getAttribute<std::string>(dom_node, literals.key, Mandatory{});
        auto value_attrib = getAttribute<std::string>(dom_node, literals.value, Mandatory{});
        return datamodel::Header::ExtDeclaration(std::move(key_attrib), std::move(value_attrib));
    }

    static datamodel::Header createHeader(const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        // read header exts
        std::vector<datamodel::Header::ExtDeclaration> exts;
        std::list<DOM_NODE_TYPE> header_ext_nodes;
        if (dom_node.findNodes(literals.ext_declaration, header_ext_nodes)) {
            for (const auto& current_header_ext_node: header_ext_nodes) {
                exts.emplace_back(createHeaderExtDeclaration(current_header_ext_node));
            }
        }
        // read the header itself
        Version version_to_set = {};
        if (auto file_ddl_version =
                getData<std::string>(dom_node, literals.language_version, AsOptional{})) {
            version_to_set = VersionConversion::fromString(*file_ddl_version);
        }
 
        // optional
        auto author = getData<std::string>(dom_node, literals.author, std::string{});
        auto date_creation = getData<std::string>(dom_node, literals.date_creation, std::string{});
        auto date_change = getData<std::string>(dom_node, literals.date_change, std::string{});
        auto description = getData<std::string>(dom_node, literals.description, std::string{});
 
        return datamodel::Header(std::move(version_to_set),
                                 std::move(author),
                                 std::move(date_creation),
                                 std::move(date_change),
                                 std::move(description),
                                 exts);
    }

    static datamodel::BaseUnit createBaseUnit(const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        auto name = getAttribute<std::string>(dom_node, literals.name, Mandatory{});
        auto symbol = getAttribute<std::string>(dom_node, literals.symbol, std::string{});
        auto description = getAttribute<std::string>(dom_node, literals.description, std::string{});
        return datamodel::BaseUnit(std::move(name), std::move(symbol), std::move(description));
    }

    static datamodel::UnitPrefix createUnitPrefix(const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        auto name = getAttribute<std::string>(dom_node, literals.name, Mandatory{});
        auto symbol = getAttribute<std::string>(dom_node, literals.symbol, std::string{});
        auto power = getAttribute<int32_t>(dom_node, literals.power, Mandatory{});
        return datamodel::UnitPrefix(std::move(name), std::move(symbol), std::move(power));
    }

    static datamodel::Unit::RefUnit createRefUnit(const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        auto unit_name = getAttribute<std::string>(dom_node, literals.name, Mandatory{});
        auto power = getAttribute<int32_t>(dom_node, literals.power, Mandatory{});
        auto prefix_name = getAttribute<std::string>(dom_node, literals.prefix, Mandatory{});
        return datamodel::Unit::RefUnit(std::move(unit_name), power, std::move(prefix_name));
    }

    static datamodel::Unit createUnit(const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
 
        // read u exts
        std::vector<datamodel::Unit::RefUnit> ref_units;
        std::list<DOM_NODE_TYPE> ref_unit_nodes;
        if (dom_node.findNodes(literals.refUnit, ref_unit_nodes)) {
            for (const auto& current_ref_unit_node: ref_unit_nodes) {
                ref_units.emplace_back(createRefUnit(current_ref_unit_node));
            }
        }
        auto name = getAttribute<std::string>(dom_node, literals.name, Mandatory{});
        auto numerator = getData<std::string>(dom_node, literals.numerator, Mandatory{});
        auto denominator = getData<std::string>(dom_node, literals.denominator, Mandatory{});
        auto offset = getData<std::string>(dom_node, literals.offset, Mandatory{});
        return datamodel::Unit(std::move(name),
                               std::move(numerator),
                               std::move(denominator),
                               std::move(offset),
                               ref_units);
    }

    static datamodel::DataType createDataType(const DOM_NODE_TYPE& dom_node,
                                              const Version& file_ddl_version,
                                              bool strict)
    {
        const auto& literals = DDXmlLiterals::getInstance();
 
        // changes between 2.0 and 3.0
        // attribute name changed to "name" from "type"
        std::string name;
        // mandatory
        if (strict && (file_ddl_version >= Version(3, 0))) {
            name = getAttribute<std::string>(dom_node, literals.name, Mandatory{});
        }
        else {
            // "type" was mandatory, but there are wrong files in the world that already used "name"
            // instead of "type" !
            auto name_attrib = getAttribute<std::string>(dom_node, literals.name, AsOptional{});
            name = name_attrib ?
                       getAttribute<std::string>(dom_node, literals.type__, *name_attrib) :
                       getAttribute<std::string>(dom_node, literals.type__, Mandatory{});
        }
        auto type_size = getAttribute<size_t>(dom_node, literals.size, Mandatory{});
 
        // optional
        auto description = getAttribute<std::string>(dom_node, literals.description, std::string{});
 
        OptionalSize array_size;
        if (auto array_size_attrib =
                getAttribute<size_t>(dom_node, literals.arraysize, AsOptional{})) {
            array_size = *array_size_attrib;
        }
 
        auto unit_name = getAttribute<std::string>(dom_node, literals.unit, std::string{});
 
        // min / max introduced in DataDefinition 3.0
        std::string min_val, max_val;
        if (file_ddl_version >= Version(3, 0) || file_ddl_version == Version(0, 0)) {
            min_val = getAttribute<std::string>(dom_node, literals.min, std::string{});
            max_val = getAttribute<std::string>(dom_node, literals.max, std::string{});
        }
 
        auto default_type_alignment =
            ddl::PredefinedDataTypes::getInstance().getDefaultAlignment(name);
 
        // create the type
        return datamodel::DataType(std::move(name),
                                   type_size,
                                   std::move(description),
                                   std::move(array_size),
                                   std::move(unit_name),
                                   std::move(min_val),
                                   std::move(max_val),
                                   default_type_alignment);
    }

    static datamodel::EnumType::Element createEnumTypeElement(const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        auto name_attrib = getAttribute<std::string>(dom_node, literals.name, Mandatory{});
        auto value_attrib = getAttribute<std::string>(dom_node, literals.value, Mandatory{});
        return datamodel::EnumType::Element(std::move(name_attrib), std::move(value_attrib));
    }

    static datamodel::EnumType createEnumType(const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        auto name_attrib = getAttribute<std::string>(dom_node, literals.name, Mandatory{});
        auto type_attrib = getAttribute<std::string>(dom_node, literals.type__, Mandatory{});
 
        datamodel::EnumType created_enum(std::move(name_attrib), std::move(type_attrib));
        std::list<DOM_NODE_TYPE> enum_element_nodes;
        if (dom_node.findNodes(literals.element, enum_element_nodes)) {
            for (const auto& current_enum_element_node: enum_element_nodes) {
                created_enum.getElements().emplace(
                    createEnumTypeElement(current_enum_element_node));
            }
        }
        return created_enum;
    }

    static datamodel::StructType::Element createStructTypeElement(const DOM_NODE_TYPE& dom_node,
                                                                  const Version& file_ddl_version,
                                                                  bool strict)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        auto name_attrib = getAttribute<std::string>(dom_node, literals.name, Mandatory{});
        auto type_attrib = getAttribute<std::string>(dom_node, literals.type__, Mandatory{});
 
        utility::Optional<size_t> byte_pos;
        ByteOrder byte_order(ByteOrder::e_le);
        utility::Optional<size_t> bit_pos;
        utility::Optional<size_t> num_bits;
        Alignment alignment_to_set = Alignment::e0;
 
        Version used_file_version = file_ddl_version;
        if (file_ddl_version == Version(0, 0) || !strict) {
            // we need to figure out the version because it i.e. a string parsing where no header is
            // set
            DOM_NODE_TYPE serialized_node;
            if (dom_node.findNode(literals.serialized, serialized_node)) {
                used_file_version = Version(4, 0);
                if (dom_node.hasAttribute(literals.valid_element_count)) {
                    used_file_version = Version(4, 2);
                }
            }
            else {
                // this is a guess!
                used_file_version = Version(3, 0);
            }
        }
 
        // From version 4.0 on this information is specified within the <serialized> tag.
        // From version 4.0 on this information is specified within the <deserialized> tag.
        if (used_file_version >= Version(4, 0)) {
            DOM_NODE_TYPE serialized_node;
            if (dom_node.findNode(literals.serialized, serialized_node)) {
                // mandatory serialized info
                auto byte_pos_int =
                    getAttribute<int>(serialized_node, literals.bytepos, Mandatory{});
                if (byte_pos_int == -1) {
                    byte_pos = {};
                }
                else {
                    byte_pos = static_cast<size_t>(byte_pos_int);
                }
                auto byte_order_attrib =
                    getAttribute<std::string>(serialized_node, literals.byteorder, Mandatory{});
                byte_order = ByteOrderConversion::fromString(byte_order_attrib, byte_order);
 
                bit_pos = getAttribute<size_t>(serialized_node, literals.bitpos, AsOptional{});
                num_bits = getAttribute<size_t>(serialized_node, literals.numbits, AsOptional{});
            }
            else {
                throw Error("DDFromXMLFactory::getAttribute",
                            "struct/element/deserialized tag was not found");
            }
 
            DOM_NODE_TYPE deserialized_node;
            if (dom_node.findNode(literals.deserialized, deserialized_node)) {
                auto alignment_attrib =
                    getAttribute<std::string>(deserialized_node, literals.alignment, Mandatory{});
                alignment_to_set =
                    AlignmentConversion::fromString(alignment_attrib, alignment_to_set);
            }
            else {
                throw Error("DDFromXMLFactory::getAttribute",
                            "struct/element/serialized tag was not found");
            }
        }
        else {
            // mandatory serialized info
            auto byte_pos_int = getAttribute<int>(dom_node, literals.bytepos, Mandatory{});
            if (byte_pos_int == -1) {
                byte_pos = {};
            }
            else {
                byte_pos = static_cast<size_t>(byte_pos_int);
            }
            auto byte_order_attrib =
                getAttribute<std::string>(dom_node, literals.byteorder, Mandatory{});
            byte_order = ByteOrderConversion::fromString(byte_order_attrib, byte_order);
 
            bit_pos = getAttribute<size_t>(dom_node, literals.bitpos, AsOptional{});
            num_bits = getAttribute<size_t>(dom_node, literals.numbits, AsOptional{});
 
            // mandatory deserialized info
            auto alignment_attrib =
                getAttribute<std::string>(dom_node, literals.alignment, Mandatory{});
            alignment_to_set = AlignmentConversion::fromString(alignment_attrib, alignment_to_set);
        }
 
        // introduced in DataDefinition 2.0
        dd::ArraySize array_size;
        if (auto arraysize_attrib =
                getAttribute<std::string>(dom_node, literals.arraysize, AsOptional{})) {
            // we check for an integrer to prevent an excpetion doin this for us
 
            if (isInteger(*arraysize_attrib)) {
                array_size =
                    ArraySize(detail::toRequiredType<size_t>(*std::move(arraysize_attrib)));
            }
            else // array size is set to a string (or an invalid value) and
                 // introduced in DataDefinition 2.0 //Dynamic array support
            {
                if (file_ddl_version >= Version(2, 0) || file_ddl_version == Version(0, 0) ||
                    !strict) {
                    array_size = ArraySize(*std::move(arraysize_attrib));
                }
            }
        }
 
        // optional
        auto description = getAttribute<std::string>(dom_node, literals.description, std::string{});
        auto comment = getAttribute<std::string>(dom_node, literals.comment, std::string{});
        auto unit_name = getAttribute<std::string>(dom_node, literals.unit, std::string{});
 
        std::string value, minimum_value, maximum_value, default_value, scale, offset,
            valid_element_count;
        // introduced in DataDefinition 2.0
        if (used_file_version >= Version(2, 0) || file_ddl_version == Version(0, 0) || !strict) {
            value = getAttribute<std::string>(dom_node, literals.value, std::string{});
        }
        // introduced in DataDefinition 3.0
        if (used_file_version >= Version(3, 0) || file_ddl_version == Version(0, 0) || !strict) {
            minimum_value = getAttribute<std::string>(dom_node, literals.min, std::string{});
            maximum_value = getAttribute<std::string>(dom_node, literals.max, std::string{});
            default_value = getAttribute<std::string>(dom_node, literals.default__, std::string{});
            scale = getAttribute<std::string>(dom_node, literals.scale, std::string{});
            offset = getAttribute<std::string>(dom_node, literals.offset, std::string{});
        }
        // introduced in DataDefinition 4.2
        if (used_file_version >= Version(4, 2) || file_ddl_version == Version(0, 0) || !strict) {
            valid_element_count =
                getAttribute<std::string>(dom_node, literals.valid_element_count, std::string{});
        }
 
        return datamodel::StructType::Element(
            std::move(name_attrib),
            std::move(type_attrib),
            datamodel::StructType::DeserializedInfo(alignment_to_set),
            datamodel::StructType::SerializedInfo(byte_pos, byte_order, bit_pos, num_bits),
            std::move(array_size),
            std::move(description),
            std::move(comment),
            std::move(unit_name),
            std::move(value),
            std::move(minimum_value),
            std::move(maximum_value),
            std::move(default_value),
            std::move(scale),
            std::move(offset),
            std::move(valid_element_count));
    }

    static datamodel::StructType createStructType(const DOM_NODE_TYPE& dom_node,
                                                  const Version& file_ddl_version,
                                                  bool strict)
    {
        using namespace std::string_literals;
        const auto& literals = DDXmlLiterals::getInstance();
        // this is very old compatibility where structs where named with type attribute
        auto type_attrib = getAttribute<std::string>(dom_node, literals.type__, AsOptional{});
        auto name_attrib = type_attrib ?
                               getAttribute<std::string>(dom_node, literals.name, *type_attrib) :
                               getAttribute<std::string>(dom_node, literals.name, Mandatory{});
        // usually the version is mandatory, but the regression test says, there are description,
        // where it is not set :-(
        auto version_attrib = getAttribute<std::string>(dom_node, literals.version, "1"s);
 
        OptionalSize alignment_to_set;
        if (auto alignment_attrib =
                getAttribute<std::string>(dom_node, literals.alignment, AsOptional{})) {
            alignment_to_set = AlignmentConversion::fromString(*alignment_attrib);
        }
        auto comment_attrib = getAttribute<std::string>(dom_node, literals.comment, std::string{});
 
        auto ddl_version_to_set = Version(0, 0);
        if (auto ddl_version_attrib =
                getAttribute<std::string>(dom_node, literals.ddlversion, AsOptional{})) {
            ddl_version_to_set = VersionConversion::fromString(*ddl_version_attrib);
        }
 
        datamodel::StructType struct_type(std::move(name_attrib),
                                          std::move(version_attrib),
                                          std::move(alignment_to_set),
                                          std::move(comment_attrib),
                                          std::move(ddl_version_to_set));
        // read elements
        std::list<DOM_NODE_TYPE> struct_element_nodes;
        if (dom_node.findNodes(literals.element, struct_element_nodes)) {
            for (const auto& current_struct_element_node: struct_element_nodes) {
                struct_type.getElements().emplace(
                    createStructTypeElement(current_struct_element_node, file_ddl_version, strict));
            }
        }
        return struct_type;
    }

    static datamodel::StreamMetaType::Property createStreamMetaTypeProperty(
        const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        auto name_attrib = getAttribute<std::string>(dom_node, literals.name, Mandatory{});
        auto type_attrib = getAttribute<std::string>(dom_node, literals.type__, Mandatory{});
        return datamodel::StreamMetaType::Property(std::move(name_attrib), std::move(type_attrib));
    }

    static datamodel::StreamMetaType createStreamMetaType(const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        auto name_attrib = getAttribute<std::string>(dom_node, literals.name, Mandatory{});
        auto version_attrib = getAttribute<std::string>(dom_node, literals.version, Mandatory{});
        auto parent_attrib = getAttribute<std::string>(dom_node, literals.parent, std::string{});
 
        datamodel::StreamMetaType created_type = datamodel::StreamMetaType(
            std::move(name_attrib), std::move(version_attrib), std::move(parent_attrib));
 
        // read properties
        std::list<DOM_NODE_TYPE> smt_prop_nodes;
        if (dom_node.findNodes(literals.property, smt_prop_nodes)) {
            for (const auto& current_smt_prop_node: smt_prop_nodes) {
                created_type.getProperties().emplace(
                    createStreamMetaTypeProperty(current_smt_prop_node));
            }
        }
        return created_type;
    }

    static datamodel::Stream::Struct createStreamStruct(const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        auto name_attrib = getAttribute<std::string>(dom_node, literals.name, std::string{});
        auto type_attrib = getAttribute<std::string>(dom_node, literals.type__, Mandatory{});
        auto byte_pos = getAttribute<size_t>(dom_node, literals.bytepos, AsOptional{});
        return datamodel::Stream::Struct(
            std::move(name_attrib), std::move(type_attrib), std::move(byte_pos));
    }

    static datamodel::Stream createStream(const DOM_NODE_TYPE& dom_node)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        auto type_attrib = getAttribute<std::string>(dom_node, literals.type__, Mandatory{});
        // we need to "try" because, there are stream definitions "in the world" where only "type"
        // was used (also as name)!
        auto name_attrib = getAttribute<std::string>(dom_node, literals.name, type_attrib);
 
        auto desc_attrib = getAttribute<std::string>(dom_node, literals.description, std::string{});
 
        datamodel::Stream created_stream = datamodel::Stream(
            std::move(name_attrib), std::move(type_attrib), std::move(desc_attrib));
        // read the structs
        std::list<DOM_NODE_TYPE> ss_nodes;
        if (dom_node.findNodes(literals.struct__, ss_nodes)) {
            for (const auto& current_stream_struct_node: ss_nodes) {
                created_stream.getStructs().emplace(createStreamStruct(current_stream_struct_node));
            }
        }
        return created_stream;
    }

    static datamodel::DataDefinition createDD(const DOM_NODE_TYPE& dom_node,
                                              const dd::Version& language_version,
                                              bool strict)
    {
        using namespace std::string_literals;
        const auto& literals = DDXmlLiterals::getInstance();
        // we use the version given, but if header exists we use the headers version
        datamodel::DataDefinition new_ddl(language_version);
        {
            DOM_NODE_TYPE header_element;
            if (dom_node.findNode(literals.header, header_element)) {
                // read header
                new_ddl.setHeader(createHeader(header_element));
            }
        }
        {
            // read BaseUnits
            std::list<DOM_NODE_TYPE> baseunit_nodes;
            if (dom_node.findNodes("//units/baseunit"s, baseunit_nodes)) {
                for (const auto& current_base_unit_node: baseunit_nodes) {
                    new_ddl.getBaseUnits().emplace(createBaseUnit(current_base_unit_node));
                }
            }
        }
        {
            // read UnitPrefix
            std::list<DOM_NODE_TYPE> prefix_nodes;
            if (dom_node.findNodes("//units/prefixes"s, prefix_nodes)) {
                for (const auto& current_prefix_node: prefix_nodes) {
                    new_ddl.getUnitPrefixes().emplace(createUnitPrefix(current_prefix_node));
                }
            }
        }
        {
            // read Unit
            std::list<DOM_NODE_TYPE> unit_nodes;
            if (dom_node.findNodes("//units/unit"s, unit_nodes)) {
                for (const auto& current_unit_node: unit_nodes) {
                    new_ddl.getUnits().emplace(
                        dd::DDFromXMLFactory<DOM_NODE_TYPE>::createUnit(current_unit_node));
                }
            }
        }
        {
            // read datatypes
            std::list<DOM_NODE_TYPE> datatype_nodes;
            if (dom_node.findNodes("//datatypes/datatype"s, datatype_nodes)) {
                for (const auto& current_datatype_node: datatype_nodes) {
                    new_ddl.getDataTypes().emplace(
                        createDataType(current_datatype_node, new_ddl.getVersion(), strict));
                }
            }
        }
        {
            // read enum types
            std::list<DOM_NODE_TYPE> enum_nodes;
            if (dom_node.findNodes("//enums/enum"s, enum_nodes)) {
                for (const auto& current_enum_node: enum_nodes) {
                    new_ddl.getEnumTypes().emplace(
                        dd::DDFromXMLFactory<DOM_NODE_TYPE>::createEnumType(current_enum_node));
                }
            }
        }
        {
            // read struct types
            std::list<DOM_NODE_TYPE> struct_nodes;
            if (dom_node.findNodes("//structs/struct"s, struct_nodes)) {
                for (const auto& current_struct_node: struct_nodes) {
                    new_ddl.getStructTypes().emplace(
                        createStructType(current_struct_node, new_ddl.getVersion(), strict));
                }
            }
        }
        // read struct types very special (only <struct></struct> is possible)
        if (dom_node.getName() == literals.struct__) {
            new_ddl.getStructTypes().emplace(
                createStructType(dom_node, new_ddl.getVersion(), strict));
        }
        // read streammetatypes
        if ((new_ddl.getVersion() >= dd::Version(4, 0)) || !strict) {
            std::list<DOM_NODE_TYPE> stream_meta_type_nodes;
            if (dom_node.findNodes("//streammetatypes/streammetatype"s, stream_meta_type_nodes)) {
                for (const auto& current_smt_node: stream_meta_type_nodes) {
                    new_ddl.getStreamMetaTypes().emplace(createStreamMetaType(current_smt_node));
                }
            }
        }
 
        {
            std::list<DOM_NODE_TYPE> stream_nodes;
            if (dom_node.findNodes("//streams/stream"s, stream_nodes)) {
                for (const auto& current_stream_node: stream_nodes) {
                    new_ddl.getStreams().emplace(createStream(current_stream_node));
                }
            }
        }
        return new_ddl;
    }
};
 
} // namespace dd
} // namespace ddl
 
#endif // DD_FROM_XML_FACTORY_H_INCLUDED