xml_ddtoxml_factory.h

Go to the documentation of this file.

 
#ifndef DD_DD_TO_XML_FACTORY_H_INCLUDED
#define DD_DD_TO_XML_FACTORY_H_INCLUDED
 
#include <ddl/dd/datamodel/datamodel_datadefinition.h>
#include <ddl/dd/datamodel/xml_literals.h>
#include <ddl/utilities/access_optional.h>
#include <ddl/utilities/ddl_error.h>
#include <ddl/utilities/std_to_string.h>
 
#include <stdexcept>
#include <string>
 
namespace ddl {
namespace dd {

template <typename DOM_NODE_TYPE>
struct DDToXMLFactory {
    template <typename T>
    static bool setOptionalAttribute(DOM_NODE_TYPE& dom_node,
                                     const std::string& attribute_name,
                                     const utility::Optional<T>& value)
    {
        if (value) {
            dom_node.setAttribute(attribute_name, std::to_string(*value));
            return true;
        }
        return false;
    }

    static bool setOptionalAttribute(DOM_NODE_TYPE& dom_node,
                                     const std::string& attribute_name,
                                     const std::string& value)
    {
        if (!value.empty()) {
            dom_node.setAttribute(attribute_name, value);
            return true;
        }
        return false;
    }

    static void setData(DOM_NODE_TYPE& dom_node,
                        const std::string& sub_node_name,
                        const std::string& value)
    {
        DOM_NODE_TYPE sub_node = dom_node.createChild(sub_node_name);
        sub_node.setData(value);
    }

    static void createNode(DOM_NODE_TYPE& parent_node, const datamodel::Header& header)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        DOM_NODE_TYPE sub_node = parent_node.createChild(literals.header);
        setData(sub_node,
                literals.language_version,
                VersionConversion::toString(header.getLanguageVersion()));
        setData(sub_node, literals.author, header.getAuthor());
        setData(sub_node, literals.date_creation, header.getDateCreation());
        setData(sub_node, literals.date_change, header.getDateChange());
        setData(sub_node, literals.description, header.getDescription());
        const auto& declarations = header.getExtDeclarations();
        for (auto ext = declarations.cbegin(); ext != declarations.cend(); ++ext) {
            DOM_NODE_TYPE sub_ext_node = sub_node.createChild(literals.ext_declaration);
            sub_ext_node.setAttribute(literals.key, ext->second->getKey());
            sub_ext_node.setAttribute(literals.value, ext->second->getValue());
        }
    }

    static void createNode(DOM_NODE_TYPE& parent_node, const datamodel::BaseUnit& base_unit)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        DOM_NODE_TYPE sub_node = parent_node.createChild(literals.baseunit);
        sub_node.setAttribute(literals.name, base_unit.getName());
        sub_node.setAttribute(literals.symbol, base_unit.getSymbol());
        sub_node.setAttribute(literals.description, base_unit.getDescription());
    }

    static void createNode(DOM_NODE_TYPE& parent_node, const datamodel::UnitPrefix& unit_prefix)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        DOM_NODE_TYPE sub_node = parent_node.createChild(literals.prefixes);
        sub_node.setAttribute(literals.name, unit_prefix.getName());
        auto power = std::to_string(unit_prefix.getPower());
        sub_node.setAttribute(literals.power, power);
        sub_node.setAttribute(literals.symbol, unit_prefix.getSymbol());
    }

    static void createNode(DOM_NODE_TYPE& parent_node, const datamodel::Unit& unit)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        DOM_NODE_TYPE sub_node = parent_node.createChild(literals.unit);
        sub_node.setAttribute(literals.name, unit.getName());
        setData(sub_node, literals.numerator, unit.getNumerator());
        setData(sub_node, literals.denominator, unit.getDenominator());
        setData(sub_node, literals.offset, unit.getOffset());
        const auto& ref_units = unit.getRefUnits();
        for (auto ref_unit = ref_units.cbegin(); ref_unit != ref_units.cend(); ++ref_unit) {
            DOM_NODE_TYPE sub_node_elem = sub_node.createChild(literals.refUnit);
            sub_node_elem.setAttribute(literals.name, (*ref_unit).getUnitName());
            sub_node_elem.setAttribute(literals.power, std::to_string((*ref_unit).getPower()));
            sub_node_elem.setAttribute(literals.prefix, (*ref_unit).getPrefixName());
        }
    }

    static void createNode(DOM_NODE_TYPE& parent_node,
                           const datamodel::DataType& data_type,
                           const Version& file_ddl_version)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        DOM_NODE_TYPE sub_node = parent_node.createChild(literals.datatype);
        // changes between 2.0 and 3.0
        // attribute name changed to "name" from "type"
        // mandatory
        if (file_ddl_version >= Version(3, 0)) {
            sub_node.setAttribute(literals.name, data_type.getName());
        }
        else {
            sub_node.setAttribute(literals.type__, data_type.getName());
        }
        sub_node.setAttribute(literals.size, std::to_string(data_type.getBitSize()));
        // optional
        setOptionalAttribute(sub_node, literals.description, data_type.getDescription());
        setOptionalAttribute<size_t>(sub_node, literals.arraysize, data_type.getArraySize());
        setOptionalAttribute(sub_node, literals.unit, data_type.getUnitName());
        // min / max introduced in DataDefinition 3.0
        if (file_ddl_version >= Version(3, 0)) {
            setOptionalAttribute(sub_node, literals.min, data_type.getMin());
            setOptionalAttribute(sub_node, literals.max, data_type.getMax());
        }
    }

    static void createNode(DOM_NODE_TYPE& parent_node, const datamodel::EnumType& enum_type)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        DOM_NODE_TYPE sub_node = parent_node.createChild(literals.enum__);
        sub_node.setAttribute(literals.name, enum_type.getName());
        sub_node.setAttribute(literals.type__, enum_type.getDataTypeName());
        const auto& elems = enum_type.getElements();
        for (auto elem = elems.cbegin(); elem != elems.cend(); ++elem) {
            DOM_NODE_TYPE sub_node_elem = sub_node.createChild(literals.element);
            sub_node_elem.setAttribute(literals.name, elem->second->getName());
            sub_node_elem.setAttribute(literals.value, elem->second->getValue());
        }
    }

    static void createNode(DOM_NODE_TYPE& parent_node,
                           const datamodel::StructType::Element& element,
                           const Version& file_ddl_version)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        DOM_NODE_TYPE sub_node = parent_node.createChild(literals.element);
        sub_node.setAttribute(literals.name, element.getName());
        sub_node.setAttribute(literals.type__, element.getTypeName());
 
        // From version 4.0 on this information is specified within the <deserialized> tag.
        DOM_NODE_TYPE* serialized_node = &sub_node;
        DOM_NODE_TYPE serialized_node_version_40;
        if (file_ddl_version >= Version(4, 0)) {
            serialized_node_version_40 = sub_node.createChild(literals.serialized);
            serialized_node = &serialized_node_version_40;
        }
        serialized_node->setAttribute(literals.bytepos, std::to_string(*element.getBytePos()));
        serialized_node->setAttribute(literals.byteorder,
                                      dd::ByteOrderConversion::toString(element.getByteOrder()));
        setOptionalAttribute<size_t>(*serialized_node, literals.bitpos, element.getBitPos());
        setOptionalAttribute<size_t>(*serialized_node, literals.numbits, element.getNumBits());
        // From version 4.0 on this information is specified within the <serialized> tag.
        DOM_NODE_TYPE* deserialized_node = &sub_node;
        DOM_NODE_TYPE deserialized_node_version_40;
        if (file_ddl_version >= Version(4, 0)) {
            deserialized_node_version_40 = sub_node.createChild(literals.deserialized);
            deserialized_node = &deserialized_node_version_40;
        }
        deserialized_node->setAttribute(literals.alignment, std::to_string(element.getAlignment()));
        // optional
        setOptionalAttribute(sub_node, literals.description, element.getDescription());
        setOptionalAttribute(sub_node, literals.unit, element.getUnitName());
        setOptionalAttribute(sub_node, literals.comment, element.getComment());
 
        // in DataDefinition 2.0 dynamic arrays are introduced
        if (file_ddl_version >= Version(2, 0) && element.getArraySize().isDynamicArraySize()) {
            setOptionalAttribute(
                sub_node, literals.arraysize, element.getArraySize().getArraySizeElementName());
        }
        else {
            auto array_size = element.getArraySize().getArraySizeValue();
            if (array_size == 0) {
                array_size = 1;
            }
            sub_node.setAttribute(literals.arraysize, std::to_string(array_size));
        }
        // introduced in DataDefinition 2.0
        if (file_ddl_version >= Version(2, 0)) {
            setOptionalAttribute(sub_node, literals.value, element.getValue());
        }
        // introduced in DataDefinition 3.0
        if (file_ddl_version >= Version(3, 0)) {
            setOptionalAttribute(sub_node, literals.min, element.getMin());
            setOptionalAttribute(sub_node, literals.max, element.getMax());
            setOptionalAttribute(sub_node, literals.default__, element.getDefault());
            setOptionalAttribute(sub_node, literals.scale, element.getScale());
            setOptionalAttribute(sub_node, literals.offset, element.getOffset());
        }
        if (file_ddl_version >= Version(4, 2)) {
            setOptionalAttribute(
                sub_node, literals.valid_element_count, element.getValidElementCount());
        }
    }

    static void createNode(DOM_NODE_TYPE& parent_node,
                           const datamodel::StructType& struct_type,
                           const Version& file_ddl_version)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        DOM_NODE_TYPE sub_node = parent_node.createChild(literals.struct__);
        sub_node.setAttribute(literals.name, struct_type.getName());
        sub_node.setAttribute(literals.version, struct_type.getVersion());
 
        setOptionalAttribute<size_t>(sub_node, literals.alignment, struct_type.getAlignment());
        setOptionalAttribute(sub_node, literals.comment, struct_type.getComment());
        if (struct_type.getLanguageVersion() != Version(0, 0)) {
            sub_node.setAttribute(literals.ddlversion,
                                  VersionConversion::toString(struct_type.getLanguageVersion()));
        }
        const auto& elements = struct_type.getElements();
        for (auto elem = elements.cbegin(); elem != elements.cend(); ++elem) {
            auto current_elem = *elem;
            createNode(sub_node, *current_elem, file_ddl_version);
        }
    }

    static void createNode(DOM_NODE_TYPE& parent_node,
                           const datamodel::StreamMetaType& stream_meta_type)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        DOM_NODE_TYPE sub_node = parent_node.createChild(literals.streammetatype);
        sub_node.setAttribute(literals.name, stream_meta_type.getName());
        sub_node.setAttribute(literals.version, stream_meta_type.getVersion());
        setOptionalAttribute(sub_node, literals.parent, stream_meta_type.getParent());
 
        const auto& props = stream_meta_type.getProperties();
        for (auto prop = props.cbegin(); prop != props.cend(); ++prop) {
            DOM_NODE_TYPE sub_prop_node = sub_node.createChild(literals.property);
            sub_prop_node.setAttribute(literals.name, prop->second->getName());
            sub_prop_node.setAttribute(literals.type__, prop->second->getType());
        }
    }

    static void createNode(DOM_NODE_TYPE& parent_node, const datamodel::Stream& stream)
    {
        const auto& literals = DDXmlLiterals::getInstance();
        DOM_NODE_TYPE sub_node = parent_node.createChild(literals.stream);
        sub_node.setAttribute(literals.name, stream.getName());
        sub_node.setAttribute(literals.type__, stream.getStreamTypeName());
        setOptionalAttribute(sub_node, literals.description, stream.getDescription());
 
        const auto& stream_structs = stream.getStructs();
        for (auto stream_struct = stream_structs.cbegin(); stream_struct != stream_structs.cend();
             ++stream_struct) {
            DOM_NODE_TYPE sub_struct_node = sub_node.createChild(literals.struct__);
            setOptionalAttribute(sub_struct_node, literals.name, (*stream_struct)->getName());
            sub_struct_node.setAttribute(literals.type__, (*stream_struct)->getTypeName());
            auto byte_pos = (*stream_struct)->getBytePos();
            if (!byte_pos) {
                byte_pos = 0;
            }
            sub_struct_node.setAttribute(literals.bytepos, std::to_string(*byte_pos));
        }
    }

    static void createNode(DOM_NODE_TYPE& parent_node, const datamodel::DataDefinition& dd)
    {
        const auto& literals = DDXmlLiterals::getInstance();
 
        createNode(parent_node, *(dd.getHeader()));
 
        DOM_NODE_TYPE units_node = parent_node.createChild(literals.units);
        // write base unit types
        const auto& base_units = dd.getBaseUnits();
        for (auto base_unit = base_units.cbegin(); base_unit != base_units.cend(); ++base_unit) {
            createNode(units_node, *(base_unit->second));
        }
        // write unit prefix types
        const auto& unit_prefixes = dd.getUnitPrefixes();
        for (auto unit_prefix = unit_prefixes.cbegin(); unit_prefix != unit_prefixes.cend();
             ++unit_prefix) {
            createNode(units_node, *(unit_prefix->second));
        }
        // write unit types
        const auto& units = dd.getUnits();
        for (auto unit = units.cbegin(); unit != units.cend(); ++unit) {
            createNode(units_node, *(unit->second));
        }
 
        // write data types
        DOM_NODE_TYPE data_types_node = parent_node.createChild(literals.datatypes);
        const auto& data_types = dd.getDataTypes();
        for (auto data_type = data_types.cbegin(); data_type != data_types.cend(); ++data_type) {
            createNode(data_types_node, *(data_type->second), dd.getVersion());
        }
        // write enum types
        DOM_NODE_TYPE enum_types_node = parent_node.createChild(literals.enums);
        const auto& enum_types = dd.getEnumTypes();
        for (auto enum_type = enum_types.cbegin(); enum_type != enum_types.cend(); ++enum_type) {
            createNode(enum_types_node, *(enum_type->second));
        }
        // write struct types
        DOM_NODE_TYPE struct_types_node = parent_node.createChild(literals.structs);
        const auto& struct_types = dd.getStructTypes();
        for (auto struct_type = struct_types.cbegin(); struct_type != struct_types.cend();
             ++struct_type) {
            createNode(struct_types_node, *(struct_type->second), dd.getVersion());
        }
 
        // write stream meta types types
        if (dd.getVersion() >= dd::Version(4, 0)) {
            DOM_NODE_TYPE stream_meta_types_node =
                parent_node.createChild(literals.streammetatypes);
            const auto& stream_meta_types_types = dd.getStreamMetaTypes();
            for (auto stream_meta_type = stream_meta_types_types.cbegin();
                 stream_meta_type != stream_meta_types_types.cend();
                 ++stream_meta_type) {
                createNode(stream_meta_types_node, *(stream_meta_type->second));
            }
        }
 
        DOM_NODE_TYPE streams_node = parent_node.createChild(literals.streams);
        const auto& streams = dd.getStreams();
        for (auto stream = streams.cbegin(); stream != streams.cend(); ++stream) {
            createNode(streams_node, *(stream->second));
        }
    }
};
} // namespace dd
} // namespace ddl
 
#endif // DD_DD_TO_XML_FACTORY_H_INCLUDED