datatypefilewriter.cpp

++ // Copyright (C) 2023 basysKom GmbH, opensource@basyskom.com

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++

++ #include "util.h"

++ #include "datatypefilewriter.h"

++ #include "enumeratedtype.h"

++ #include "enumeratedvalue.h"

++ #include "field.h"

++ #include "stringidentifier.h"

++ #include "structuredtype.h"

++

++ #include <QtCore/qdir.h>

++ #include <QtCore/qfile.h>

++ #include <QtCore/qset.h>

++

++ using namespace Qt::Literals::StringLiterals;

++

++ DataTypeFileWriter::DataTypeFileWriter(const QString &path,

++                                        const QString &prefix,

++                                        const QString &header)

++     : m_path(path)

++     , m_prefix(prefix)

++     , m_header(header)

++ {}

++

++ void DataTypeFileWriter::visit(XmlElement *xmlElement)

++ {

++     Q_UNUSED(xmlElement);

++ }

++

++ void DataTypeFileWriter::visit(EnumeratedType *enumeratedType)

++ {

++     bool isPrecodedType = false;

++     for (const auto &precodedType : StringIdentifier::opcUaPrecodedTypes) {

++         if (precodedType.contains(enumeratedType->name())) {

++             isPrecodedType = true;

++             break;

++         }

++     }

++     if (!isPrecodedType) {

++         m_generateMapping.append(enumeratedType);

++     }

++ }

++

++ void DataTypeFileWriter::visit(EnumeratedValue *enumeratedValue)

++ {

++     Q_UNUSED(enumeratedValue);

++ }

++

++ void DataTypeFileWriter::visit(Field *field)

++ {

++     Q_UNUSED(field);

++ }

++

++ void DataTypeFileWriter::visit(Import *import)

++ {

++     Q_UNUSED(import);

++ }

++

++ void DataTypeFileWriter::visit(StructuredType *structuredType)

++ {

++     if (!structuredType->fields().empty()) {

++         bool isPrecodedType = false;

++         for (const auto &precodedType : StringIdentifier::opcUaPrecodedTypes) {

++             if (precodedType.contains(structuredType->name())) {

++                 isPrecodedType = true;

++                 break;

++             }

++         }

++         if (!isPrecodedType) {

++             m_generateMapping.append(structuredType);

++         }

++     }

++ }

++

++ void DataTypeFileWriter::visit(TypeDictionary *typeDictionary)

++ {

++     Q_UNUSED(typeDictionary);

++ }

++

++ void DataTypeFileWriter::writeLicenseHeader(QTextStream &output)

++ {

++     if (!m_header.isEmpty())

++         output << m_header << Util::lineBreak(2);

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCpp(const StructuredType *structuredType,

++                                                 QTextStream &output)

++ {

++     if (!m_generatedStructuredTypeFilenames.contains(

++             u"%1%2"_s.arg(m_prefix, structuredType->name())))

++         m_generatedStructuredTypeFilenames.push_back(

++             u"%1%2"_s.arg(m_prefix, structuredType->name()));

++     output << "#include \"" << m_prefix.toLower() << structuredType->name().toLower() << ".h\"";

++

++     QList<QString> mutualIncludes;

++     const auto typeFields = structuredType->fields();

++     for (const auto field : typeFields) {

++         const auto typeName = field->typeNameSecondPart();

++         for (const auto &type : std::as_const(m_generateMapping)) {

++             StructuredType *tempStructuredType = dynamic_cast<StructuredType *>(type);

++             if (tempStructuredType) {

++                 if (tempStructuredType == structuredType)

++                     continue;

++                 const auto tempFields = tempStructuredType->fields();

++                 for (const auto &tempField : tempFields) {

++                     if (typeName == tempStructuredType->name()

++                         && tempField->typeNameSecondPart() == structuredType->name()) {

++                         if (!mutualIncludes.contains(

++                                 u"#include \"%1%2.h\"\n"_s

++                                     .arg(m_prefix.toLower(), tempStructuredType->name().toLower())))

++                             mutualIncludes.push_back(

++                                 u"#include \"%1%2.h\"\n"_s

++                                     .arg(m_prefix.toLower(), tempStructuredType->name().toLower()));

++                     }

++                 }

++             }

++         }

++     }

++     if (!mutualIncludes.isEmpty()) {

++         output << Util::lineBreak();

++         std::sort(mutualIncludes.begin(), mutualIncludes.end());

++         for (const auto &include : mutualIncludes) {

++             output << include;

++         }

++     }

++     if (structuredType->recursive()) {

++         output << Util::lineBreak();

++         output << "#include <optional>";

++         output << Util::lineBreak();

++     }

++     output << Util::lineBreak(2);

++

++     writeStructuredTypeCppClassComment(structuredType, output);

++     writeStructuredTypeCppDataClass(structuredType, output);

++     writeStructuredTypeCppConstructors(structuredType, output);

++     writeStructuredTypeCppOperatorAssignment(structuredType, output);

++     writeStructuredTypeCppOperatorEquality(structuredType, output);

++     writeStructuredTypeCppQVariant(structuredType, output);

++     writeStructuredTypeCppDestructor(structuredType, output);

++     writeStructuredTypeCppGetterSetter(structuredType, output);

++     writeStructuredTypeCppDebug(structuredType, output);

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppClassComment(const StructuredType *structuredType,

++                                                             QTextStream &output)

++ {

++     output << "/*!"

++            << Util::lineBreak();

++     output << Util::indent(1) << "\\class " << m_prefix << structuredType->name() << Util::lineBreak();

++     output << Util::indent(1) << "\\brief the OPC UA " << structuredType->name() << "."

++            << Util::lineBreak();

++     output << "*/"

++            << Util::lineBreak();

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppDataClass(const StructuredType *structuredType,

++                                                          QTextStream &output)

++ {

++     output << "class " << m_prefix << structuredType->name() << "Data : public QSharedData"

++            << Util::lineBreak();

++     output << "{"

++            << Util::lineBreak();

++     output << "public:"

++            << Util::lineBreak();

++

++     writeStructuredTypeCppDataClassMember(structuredType, output);

++

++     output << "};"

++            << Util::lineBreak(2);

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppDataClassMember(const StructuredType *structuredType,

++                                                                QTextStream &output)

++ {

++     const auto typeFields = structuredType->fields();

++     QList<Field *> unionMember;

++     if (structuredType->hasUnion()) {

++         for (const auto &possibleUnionMember : typeFields) {

++             for (const auto &field : typeFields) {

++                 if (field->isUnion()) {

++                     if (field->switchField() == possibleUnionMember->name()

++                         && !unionMember.contains(possibleUnionMember))

++                         unionMember.push_back(possibleUnionMember);

++                 }

++             }

++         }

++     }

++     QList<Field *> arrayLengthfields;

++     for (const auto &possibleArrayLengthField : typeFields) {

++         for (const auto &field : typeFields) {

++             if (possibleArrayLengthField->name() == field->lengthField()

++                 && !arrayLengthfields.contains(possibleArrayLengthField))

++                 arrayLengthfields.push_back(possibleArrayLengthField);

++         }

++     }

++

++     QList<Field *> switchFields;

++     if (structuredType->hasSwitchfield()) {

++         for (const auto &possibleOptionalMember : typeFields) {

++             for (const auto &field : typeFields) {

++                 if (!possibleOptionalMember->switchField().isEmpty() && possibleOptionalMember->switchField() == field->name())

++                     switchFields.push_back(field);

++             }

++         }

++     }

++

++     for (const auto &field : typeFields) {

++         if (field->isInStructuredTypeBitMask() && !switchFields.contains(field))

++             continue;

++

++         bool isEnumeration = false;

++         for (const auto &enumeratedType : std::as_const(m_enumeratedTypes)) {

++             if (enumeratedType->name() == field->typeName().split(':'_L1).at(1)) {

++                 isEnumeration = true;

++                 field->setIsEnum(true);

++             }

++         }

++

++         bool isPreCoded = false;

++         if (!arrayLengthfields.contains(field)) {

++             if (!unionMember.contains(field)) {

++                 output << Util::indent(1);

++                 if (StringIdentifier::typeNameDataTypeConverter.contains(field->typeName())) {

++                     if (!field->needContainer()) {

++                         output << StringIdentifier::typeNameDataTypeConverter.value(

++                             field->typeName())

++                                << " ";

++                     } else {

++                         output << "QList<"

++                                << StringIdentifier::typeNameDataTypeConverter.value(

++                                       field->typeName())

++                                << "> ";

++                     }

++                 } else {

++                     const auto typeName = field->typeNameSecondPart();

++                     for (const auto &preCodedType : StringIdentifier::opcUaPrecodedTypes) {

++                         if (preCodedType.contains(typeName)) {

++                             isPreCoded = true;

++                             if (field->needContainer())

++                                 output << "QList<";

++                             if (preCodedType.deEncoderName().isEmpty())

++                                 output << preCodedType.className();

++                             else

++                                 output << preCodedType.deEncoderName();

++                             if (field->needContainer())

++                                 output << ">";

++                             output << " ";

++                             break;

++                         }

++                     }

++                     if (!isPreCoded) {

++                         if (field->needContainer())

++                             output << "QList<" << m_prefix << typeName << "> ";

++                         else if (field->recursive())

++                             output << "std::optional<" << m_prefix << typeName << "> ";

++                         else if (isEnumeration)

++                             output << m_prefix << "::" << typeName << " ";

++                         else

++                             output << m_prefix << typeName << " ";

++                     }

++                 }

++

++                 const auto lowerCaseFieldName = field->lowerFirstName();

++                 output << lowerCaseFieldName;

++                 if (!field->needContainer()) {

++                     if (StringIdentifier::typeNameDataTypeConverter.contains(field->typeName())) {

++                         if (field->typeName().contains(StringIdentifier::integerIdentifier)

++                             || field->typeName().contains(StringIdentifier::doubleIdentifier)

++                             || field->typeName().contains(StringIdentifier::floatIdentifier)

++                             || field->typeName().contains(StringIdentifier::byteIdentifier)

++                             || field->typeName().contains(StringIdentifier::sbyteIdentifier))

++                             output << " {0}";

++                         else if (field->typeName().contains(StringIdentifier::booleanIdentifier)

++                                  || field->typeName().contains(StringIdentifier::bitIdentifier))

++                             output << " {false}";

++                     } else if (field->isEnum()) {

++                         const auto enumType = std::find_if(m_enumeratedTypes.constBegin(), m_enumeratedTypes.constEnd(),

++                                                            [field](EnumeratedType *e) { return e->name() == field->typeNameSecondPart(); });

++                         const auto firstValueName = enumType != m_enumeratedTypes.constEnd() && !(*enumType)->values().empty()

++                                                         ? (*enumType)->values().first()->name() : u"Unknown"_s;

++                         if (!firstValueName.isEmpty())

++                             output << " {" << m_prefix << "::" << field->typeNameSecondPart() << "::" << firstValueName << "}";

++                         else

++                             output << " {}";

++                     } else {

++                         if (field->typeName().contains(StringIdentifier::uaStatusCodeIdentifier))

++                             output << " {QOpcUa::UaStatusCode::Good}";

++                     }

++                 }

++                 output << ";"

++                        << Util::lineBreak();

++             } else {

++                 const auto fieldNameLowerCase = field->lowerFirstName();

++                 output << Util::indent(1) << m_prefix << structuredType->name() << "::" << field->name()

++                        << " " << fieldNameLowerCase << " = " << m_prefix << structuredType->name()

++                        << "::" << field->name() << "::"

++                        << "None";

++

++                 output << ";"

++                        << Util::lineBreak();

++             }

++         }

++     }

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppConstructors(const StructuredType *structuredType,

++                                                             QTextStream &output)

++ {

++     output << m_prefix << structuredType->name() << "::" << m_prefix << structuredType->name()

++            << "()"

++            << Util::lineBreak();

++     output << "   : data(new " << m_prefix << structuredType->name() << "Data)\n";

++     output << "{"

++            << Util::lineBreak();

++     output << "}"

++            << Util::lineBreak(2);

++

++     output << "/*!"

++            << Util::lineBreak();

++     output << "   Constructs a " << structuredType->name() << " from \\a rhs"

++            << Util::lineBreak();

++     output << "*/"

++            << Util::lineBreak();

++     output << m_prefix << structuredType->name() << "::" << m_prefix << structuredType->name()

++            << "(const " << m_prefix << structuredType->name() << " &rhs)"

++            << Util::lineBreak();

++     output << "   : data(rhs.data)"

++            << Util::lineBreak();

++     output << "{"

++            << Util::lineBreak();

++     output << "}"

++            << Util::lineBreak(2);

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppOperatorAssignment(

++     const StructuredType *structuredType, QTextStream &output)

++ {

++     output << "/*!"

++            << Util::lineBreak();

++     output << "   Sets the values from \\a rhs in this " << structuredType->name() << Util::lineBreak();

++     output << "*/"

++            << Util::lineBreak();

++     output << m_prefix << structuredType->name() << " &" << m_prefix << structuredType->name()

++            << "::operator=(const " << m_prefix << structuredType->name() << " &rhs)"

++            << Util::lineBreak();

++     output << "{"

++            << Util::lineBreak();

++     output << Util::indent(1) << "if (this != &rhs)"

++            << Util::lineBreak();

++     output << Util::indent(2) << "data.operator=(rhs.data);"

++            << Util::lineBreak();

++     output << Util::indent(1) << "return *this;"

++            << Util::lineBreak();

++     output << "}"

++            << Util::lineBreak(2);

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppOperatorEquality(const StructuredType *structuredType,

++                                                                 QTextStream &output)

++ {

++     output << "/*!"

++            << Util::lineBreak();

++     output << Util::indent(1) << "Returns \\c true if this " << structuredType->name()

++            << " has the same value as \\a rhs"

++            << Util::lineBreak();

++     output << "*/"

++            << Util::lineBreak();

++

++     output << "bool " << m_prefix << structuredType->name() << "::operator==(const " << m_prefix

++            << structuredType->name() << " &rhs) const"

++            << Util::lineBreak();

++     output << "{"

++            << Util::lineBreak();

++     QList<Field *> unionSwitchfield;

++     QList<Field *> arrayLengthfields;

++

++     const auto typeFields = structuredType->fields();

++

++     for (const auto &possibleMember : typeFields) {

++         for (const auto &field : typeFields) {

++             if (possibleMember->name() == field->lengthField()

++                 && !arrayLengthfields.contains(possibleMember))

++                 arrayLengthfields.push_back(possibleMember);

++             if (possibleMember->name() == field->switchField()

++                 && !unionSwitchfield.contains(possibleMember) && field->isUnion())

++                 unionSwitchfield.push_back(possibleMember);

++         }

++     }

++

++     if (!unionSwitchfield.isEmpty()) {

++         const auto switchField = unionSwitchfield.first()->lowerFirstName();

++         output << Util::indent(1) << "if (data->" << switchField << " != " << " rhs.data->" << switchField << ")" << Util::lineBreak();

++         output << Util::indent(2) << "return false;" << Util::lineBreak(2);

++     }

++

++     if (structuredType->containsBitMask()) {

++         for (const auto &field : typeFields) {

++             if (!field->switchField().isEmpty() && !arrayLengthfields.contains(field)) {

++                 const auto switchField = Util::lowerFirstLetter(field->switchField());

++                 output << Util::indent(1) << "if (data->" << switchField << " != rhs.data->" << switchField << " || (data->" << switchField << " && ";

++                 output << "!(data->" << field->lowerFirstName() << " == rhs.data->" << field->lowerFirstName() << ")";

++                 output << "))";

++                 output << Util::lineBreak() << Util::indent(2) << "return false;" << Util::lineBreak();

++             }

++         }

++         output << Util::lineBreak();

++     }

++

++     auto counterGeneratedTypes = 0;

++     if (structuredType->hasUnion()) {

++         for (const auto &field : typeFields) {

++             if (!arrayLengthfields.contains(field) && !unionSwitchfield.contains(field) && !field->isInStructuredTypeBitMask()) {

++                 if (structuredType->containsBitMask() && !field->switchField().isEmpty())

++                     continue;

++

++

++                 output << Util::indent(1) << "if (static_cast<qint32>(data->" << unionSwitchfield.first()->lowerFirstName() << ") == " << field->switchValue() << " && ";

++                 output << "!(data->" << field->lowerFirstName() << " == rhs.data->" << field->lowerFirstName() << ")";

++                 output << ")" << Util::lineBreak();

++                 output << Util::indent(2) << "return false;" << Util::lineBreak(2);

++             }

++         }

++

++         output << Util::indent(1) << "return true;" << Util::lineBreak();

++     } else {

++         output << Util::indent(1) << "return ";

++

++         for (const auto &field : typeFields) {

++             if (!arrayLengthfields.contains(field) && !unionSwitchfield.contains(field) && !field->isInStructuredTypeBitMask()) {

++                 if (structuredType->containsBitMask() && !field->switchField().isEmpty())

++                     continue;

++

++                 const auto memberName = field->lowerFirstName();

++                 if (counterGeneratedTypes != 0)

++                     output << Util::lineBreak() << Util::indent(2) << "   && ";

++                 output << "data->" << memberName << " == rhs.data->" << memberName;

++                 counterGeneratedTypes++;

++             }

++         }

++

++         output << ";" << Util::lineBreak();

++     }

++

++     output << "}"

++            << Util::lineBreak(2);

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppQVariant(const StructuredType *structuredType,

++                                                         QTextStream &output)

++ {

++     output << "/*!"

++            << Util::lineBreak();

++     output << "   Converts this " << structuredType->name() << " to \\l QVariant"

++            << Util::lineBreak();

++     output << "*/"

++            << Util::lineBreak();

++

++     output << m_prefix << structuredType->name() << "::operator QVariant() const"

++            << Util::lineBreak();

++     output << "{"

++            << Util::lineBreak();

++     output << Util::indent(1) << "return QVariant::fromValue(*this);"

++            << Util::lineBreak();

++     output << "}"

++            << Util::lineBreak(2);

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppDestructor(const StructuredType *structuredType,

++                                                           QTextStream &output)

++ {

++     output << m_prefix << structuredType->name() << "::~" << m_prefix << structuredType->name()

++            << "()"

++            << Util::lineBreak();

++     output << "{"

++            << Util::lineBreak();

++     output << "}"

++            << Util::lineBreak(2);

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppGetterSetter(const StructuredType *structuredType,

++                                                             QTextStream &output)

++ {

++     writeStructuredTypeCppGetter(structuredType, output);

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppGetter(const StructuredType *structuredType,

++                                                       QTextStream &output)

++ {

++     QList<Field *> unionMember;

++

++     const auto typeFields = structuredType->fields();

++

++     if (structuredType->hasUnion()) {

++         for (const auto &possibleUnionMember : typeFields) {

++             for (const auto &field : typeFields) {

++                 if (field->isUnion()) {

++                     if (field->switchField() == possibleUnionMember->name()

++                         && !unionMember.contains(possibleUnionMember))

++                         unionMember.push_back(possibleUnionMember);

++                 }

++             }

++         }

++     }

++     QList<Field *> arrayLengthfields;

++     for (const auto &possibleArrayLengthField : typeFields) {

++         for (const auto &field : typeFields) {

++             if (possibleArrayLengthField->name() == field->lengthField()

++                 && !arrayLengthfields.contains(possibleArrayLengthField))

++                 arrayLengthfields.push_back(possibleArrayLengthField);

++         }

++     }

++

++     QList<Field *> switchFields;

++     if (structuredType->hasSwitchfield()) {

++         for (const auto &possibleOptionalMember : typeFields) {

++             for (const auto &field : typeFields) {

++                 if (!possibleOptionalMember->switchField().isEmpty() && possibleOptionalMember->switchField() == field->name())

++                     switchFields.push_back(field);

++             }

++         }

++     }

++

++     for (const auto &field : typeFields) {

++         if (!arrayLengthfields.contains(field) && !(field->isInStructuredTypeBitMask() && !switchFields.contains(field))) {

++             const auto tmpFunctionName = field->lowerFirstName();

++

++             output << "/*!\n";

++             output << Util::indent(1) << "Returns the field " << field->name() << " of this " << structuredType->name() << " object"

++                    << Util::lineBreak();

++             output << "*/\n";

++

++             const auto typeName = field->typeNameSecondPart();

++             if (!unionMember.contains(field)) {

++                 if (field->needContainer())

++                     output << "QList<";

++                 if (StringIdentifier::typeNameDataTypeConverter.contains(field->typeName())) {

++                     output << StringIdentifier::typeNameDataTypeConverter.value(field->typeName());

++                 } else {

++                     bool isPreCoded = false;

++                     for (const auto &preCodedType : StringIdentifier::opcUaPrecodedTypes) {

++                         if (preCodedType.contains(typeName)) {

++                             isPreCoded = true;

++                             if (preCodedType.deEncoderName().isEmpty())

++                                 output << preCodedType.className();

++                             else

++                                 output << preCodedType.deEncoderName();

++                             break;

++                         }

++                     }

++                     if (!isPreCoded) {

++                         bool isEnum = false;

++                         for (const auto &enumeratedType : std::as_const(m_enumeratedTypes)) {

++                             if (enumeratedType->name() == field->typeName().split(':'_L1).at(1))

++                                 isEnum = true;

++                         }

++                         if (isEnum)

++                             output << m_prefix << "::" << field->typeName().split(':'_L1).at(1);

++                         else

++                             output << m_prefix << typeName;

++                     }

++                 }

++                 if (field->needContainer())

++                     output << ">";

++                 output << " ";

++

++             } else {

++                 output << m_prefix << structuredType->name() << "::" << field->name() << " ";

++             }

++

++             output << m_prefix << structuredType->name() << "::" << tmpFunctionName << "() const"

++                    << Util::lineBreak();

++             output << "{"

++                    << Util::lineBreak();

++             if (!field->isUnion()) {

++                 if (field->recursive())

++                     if (field->needContainer()) {

++                         output << Util::indent(1) << "return data->" << tmpFunctionName << ";"

++                                << Util::lineBreak();

++                     } else {

++                         output << Util::indent(1) << "return data->" << tmpFunctionName << ".value_or(" << m_prefix

++                                << field->typeName().split(':'_L1).at(1) << "()"

++                                << ");"

++                                << Util::lineBreak();

++                     }

++                 else

++                     output << Util::indent(1) << "return data->" << tmpFunctionName << ";"

++                            << Util::lineBreak();

++             } else {

++                 const auto switchfieldToLower = Util::lowerFirstLetter(field->switchField());

++                 output << Util::indent(1) << "if (data->" << switchfieldToLower << " == " << m_prefix

++                        << structuredType->name() << "::" << field->switchField()

++                        << "::" << field->name() << ")"

++                        << Util::lineBreak();

++                 output << Util::indent(2) << "return data->" << tmpFunctionName << ";"

++                        << Util::lineBreak();

++                 output << Util::indent(1) << "else"

++                        << Util::lineBreak();

++                 output << Util::indent(2) << "return {};" << Util::lineBreak();

++             }

++             output << "}"

++                    << Util::lineBreak(2);

++             if (!unionMember.contains(field))

++                 writeStructuredTypeCppSetter(field, structuredType, output);

++         }

++     }

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppSetter(const Field *field,

++                                                       const StructuredType *structuredType,

++                                                       QTextStream &output)

++ {

++     output << "/*!"

++            << Util::lineBreak();

++     output << Util::indent(1) << "Sets the field " << field->name() << " of this " << structuredType->name() << " object to \\a "

++            << field->lowerFirstName() << Util::lineBreak();

++     output << "*/"

++            << Util::lineBreak();

++

++     output << "void " << m_prefix << structuredType->name() << "::set" << field->name() << "(";

++     const auto tmpFunctionName = field->lowerFirstName();

++     if (StringIdentifier::typeNameDataTypeConverter.contains(field->typeName())) {

++         if (field->typeName().contains(StringIdentifier::booleanIdentifier)

++             || field->typeName().contains(StringIdentifier::integerIdentifier)

++             || field->typeName().contains(StringIdentifier::floatIdentifier)

++             || field->typeName().contains(StringIdentifier::doubleIdentifier)) {

++             if (field->needContainer())

++                 output << "QList<"

++                        << StringIdentifier::typeNameDataTypeConverter.value(field->typeName())

++                        << "> ";

++             else

++                 output << StringIdentifier::typeNameDataTypeConverter.value(field->typeName())

++                        << " ";

++         } else {

++             output << "const ";

++             if (field->needContainer())

++                 output << "QList<"

++                        << StringIdentifier::typeNameDataTypeConverter.value(field->typeName())

++                        << "> &";

++             else

++                 output << StringIdentifier::typeNameDataTypeConverter.value(field->typeName())

++                        << " &";

++         }

++     } else {

++         const auto typeName = field->typeNameSecondPart();

++         bool isPreCoded = false;

++         for (const auto &preCodedType : StringIdentifier::opcUaPrecodedTypes) {

++             if (preCodedType.contains(typeName)) {

++                 isPreCoded = true;

++                 output << "const ";

++                 if (field->needContainer())

++                     output << "QList<";

++                 if (preCodedType.deEncoderName().isEmpty())

++                     output << preCodedType.className();

++                 else

++                     output << preCodedType.deEncoderName();

++                 if (field->needContainer())

++                     output << ">";

++                 output << " &";

++                 break;

++             }

++         }

++

++         if (!isPreCoded) {

++             bool isEnum = false;

++             for (const auto &enumeratedType : std::as_const(m_enumeratedTypes)) {

++                 if (enumeratedType->name() == field->typeName().split(':'_L1).at(1))

++                     isEnum = true;

++             }

++             output << "const ";

++             if (field->needContainer())

++                 output << "QList <" << m_prefix << typeName << "> &";

++             else if (isEnum)

++                 output << m_prefix << "::" << field->typeName().split(':'_L1).at(1) << " &";

++             else

++                 output << m_prefix << typeName << " &";

++         }

++     }

++     output << tmpFunctionName << ")"

++            << Util::lineBreak();

++     output << "{"

++            << Util::lineBreak();

++     output << Util::indent(1) << "data->" << tmpFunctionName << " = " << tmpFunctionName << ";"

++            << Util::lineBreak();

++     if (field->isUnion()) {

++         const auto switchfieldToLower = Util::lowerFirstLetter(field->switchField());

++         output << Util::indent(1) << "data->" << switchfieldToLower << " = " << m_prefix << structuredType->name()

++                << "::" << field->switchField() << "::" << field->name() << ";"

++                << Util::lineBreak();

++     }

++     output << "}"

++            << Util::lineBreak(2);

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeHeader(const StructuredType *structuredType,

++                                                    QTextStream &output)

++ {

++     output << "#pragma once"

++            << Util::lineBreak();

++

++     writeStructuredTypeHeaderIncludes(structuredType, output);

++

++     output << "class " << m_prefix << structuredType->name() << Util::lineBreak();

++     output << "{"

++            << Util::lineBreak();

++     output << "public:"

++            << Util::lineBreak();

++

++     writeStructuredTypeHeaderUnion(structuredType, output);

++

++     output << Util::indent(1) << m_prefix << structuredType->name() << "();"

++            << Util::lineBreak();

++     output << Util::indent(1) << m_prefix << structuredType->name() << "(const " << m_prefix

++            << structuredType->name() << " &);"

++            << Util::lineBreak();

++     output << Util::indent(1) << m_prefix << structuredType->name() << " &operator=(const " << m_prefix

++            << structuredType->name() << " &rhs);"

++            << Util::lineBreak();

++     output << Util::indent(1) << "bool operator==(const " << m_prefix << structuredType->name() << " &rhs) const;"

++            << Util::lineBreak();

++     output << Util::indent(1) << "inline bool operator!=(const " << m_prefix << structuredType->name() << " &rhs) const"

++            << Util::lineBreak(1)

++            << Util::indent(2) << "{ return !(*this == rhs); }"

++            << Util::lineBreak();

++     output << Util::indent(1) << "operator QVariant() const;"

++            << Util::lineBreak();

++     output << Util::indent(1) << "~" << m_prefix << structuredType->name() << "();"

++            << Util::lineBreak(2);

++

++     writeStructuredTypeHeaderGetterSetter(structuredType, output);

++

++     writeStructuredTypeHeaderDebug(structuredType, output);

++

++     output << "private:"

++            << Util::lineBreak();

++     output << Util::indent(1) << "QSharedDataPointer<" << m_prefix << structuredType->name() << "Data> data;"

++            << Util::lineBreak();

++     output << "};"

++            << Util::lineBreak(2);

++     output << "Q_DECLARE_METATYPE(" << m_prefix << structuredType->name() << ")"

++            << Util::lineBreak();

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeHeaderIncludes(const StructuredType *structuredType,

++                                                            QTextStream &output)

++ {

++     QList<QString> qtCoreIncludes{u"#include <QSharedData>\n"_s,

++                                   u"#include <QVariant>\n"_s};

++     QList<QString> qtOpcUaIncludes{};

++     QList<QString> qtClassIncludes;

++     QList<QString> qtPredifinedClasses;

++

++     const auto typeFields = structuredType->fields();

++

++     for (const auto &field : typeFields) {

++         const auto typeName = field->typeNameSecondPart();

++         QString include;

++         if (field->typeName().startsWith(u"%1:"_s.arg(StringIdentifier::binaryTypeIdentifier))) {

++             if (typeName == StringIdentifier::datetimeIdentifier) {

++                 include = u"#include <QDateTime>\n"_s;

++             } else if (typeName == StringIdentifier::byteStringIdentifier) {

++                 include = u"#include <QByteArray>\n"_s;

++             } else if (typeName == StringIdentifier::charArrayIdentifier) {

++                 include = u"#include <QString>\n"_s;

++             } else if (typeName == StringIdentifier::guidIdentifier) {

++                 include = u"#include <QUuid>\n"_s;

++             }

++

++             if (!qtCoreIncludes.contains(include)) {

++                 qtCoreIncludes.push_back(include);

++             }

++         } else {

++             bool isPrecoded = false;

++             for (const auto &precodedType : StringIdentifier::opcUaPrecodedTypes) {

++                 if (precodedType.contains(typeName)) {

++                     isPrecoded = true;

++                     if (!precodedType.filename().isEmpty()) {

++                         include = u"#include <QtOpcUa/%1>\n"_s

++                                       .arg(precodedType.filename());

++                         break;

++                     }

++                 }

++             }

++             if (typeName != structuredType->name()) {

++                 if (!isPrecoded) {

++                     bool isEnum = false;

++                     for (const auto &enumeratedType : std::as_const(m_enumeratedTypes)) {

++                         if (enumeratedType->name() == typeName)

++                             isEnum = true;

++                     }

++                     if (isEnum) {

++                         if (!qtClassIncludes.contains(

++                                 u"#include \"%1enumerations.h\"\n"_s

++                                     .arg(m_prefix.toLower())))

++                             qtClassIncludes.push_back(

++                                 u"#include \"%1enumerations.h\"\n"_s

++                                     .arg(m_prefix.toLower()));

++

++                     } else {

++                         bool isMutualInclude = false;

++                         for (const auto &type : std::as_const(m_generateMapping)) {

++                             StructuredType *tempStructuredType = dynamic_cast<StructuredType *>(

++                                 type);

++                             if (tempStructuredType) {

++                                 if (tempStructuredType == structuredType)

++                                     continue;

++                                 const auto tempFields = tempStructuredType->fields();

++                                 for (const auto &tempField : tempFields) {

++                                     const auto tempTypeName = tempField->typeNameSecondPart();

++                                     if (typeName == tempStructuredType->name()

++                                         && tempTypeName == structuredType->name()) {

++                                         isMutualInclude = true;

++                                         if (!qtPredifinedClasses.contains(

++                                                 u"%1%2"_s.arg(m_prefix, tempStructuredType->name())))

++                                             qtPredifinedClasses.push_back(

++                                                 u"%1%2"_s.arg(m_prefix, tempStructuredType->name()));

++                                     }

++                                 }

++                             }

++                         }

++

++                         if (!qtClassIncludes.contains(

++                                 u"#include \"%1%2.h\"\n"_s

++                                     .arg(m_prefix.toLower(), typeName.toLower()))

++                             && !isMutualInclude

++                             && typeName != StringIdentifier::xmlElementIdentifier)

++                             qtClassIncludes.push_back(

++                                 u"#include \"%1%2.h\"\n"_s

++                                     .arg(m_prefix.toLower(), typeName.toLower()));

++                     }

++                 } else {

++                     if (!qtOpcUaIncludes.contains(include)) {

++                         qtOpcUaIncludes.push_back(include);

++                     }

++                 }

++             }

++         }

++         if (field->needContainer()) {

++             include = u"#include <QList>\n"_s;

++             if (!qtCoreIncludes.contains(include)) {

++                 qtCoreIncludes.push_back(include);

++             }

++         }

++     }

++     if (!qtClassIncludes.isEmpty()) {

++         std::sort(qtClassIncludes.begin(), qtClassIncludes.end());

++         for (const auto &include : qtClassIncludes) {

++             output << include;

++         }

++         output << Util::lineBreak();

++     }

++     std::sort(qtOpcUaIncludes.begin(), qtOpcUaIncludes.end());

++     for (const auto &include : qtOpcUaIncludes) {

++         output << include;

++     }

++     output << Util::lineBreak();

++     std::sort(qtCoreIncludes.begin(), qtCoreIncludes.end());

++     for (const auto &include : qtCoreIncludes) {

++         output << include;

++     }

++     output << Util::lineBreak();

++

++     if (!qtPredifinedClasses.isEmpty()) {

++         std::sort(qtPredifinedClasses.begin(), qtPredifinedClasses.end());

++         for (const auto &predefinedClass : qtPredifinedClasses) {

++             output << "class " << predefinedClass << ";"

++                    << Util::lineBreak();

++         }

++     }

++

++     output << "class " << m_prefix << structuredType->name() << "Data;"

++            << Util::lineBreak();

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeHeaderUnion(const StructuredType *structuredType,

++                                                         QTextStream &output)

++ {

++     if (structuredType->hasUnion()) {

++         QList<Field *> unions;

++         QList<Field *> switchFields;

++

++         const auto typeFields = structuredType->fields();

++

++         for (const auto &field : typeFields) {

++             if (field->isUnion())

++                 switchFields.push_back(field);

++         }

++         for (const auto &switchField : switchFields) {

++             for (const auto &structuredTypeField : typeFields) {

++                 if (switchField->switchField() == structuredTypeField->name()) {

++                     if (!unions.contains(structuredTypeField))

++                         unions.push_back(structuredTypeField);

++                 }

++             }

++         }

++         QList<Field *> arrayLengthfields;

++         for (const auto &possibleArrayLengthField : typeFields) {

++             for (const auto &field : typeFields) {

++                 if (possibleArrayLengthField->name() == field->lengthField()

++                     && !arrayLengthfields.contains(possibleArrayLengthField))

++                     arrayLengthfields.push_back(possibleArrayLengthField);

++             }

++         }

++         for (const auto &field : unions) {

++             output << Util::indent(1) << "enum class " << field->name() << " {"

++                    << Util::lineBreak();

++             output << Util::indent(2) << "None = 0,\n";

++             for (int i = 0; i < switchFields.size(); i++) {

++                 const int nextField = i + 1;

++                 if (!arrayLengthfields.contains(switchFields.at(i))) {

++                     if (nextField >= switchFields.size()) {

++                         if (switchFields.at(i)->switchField() == field->name()) {

++                             output << Util::indent(2) << switchFields.at(i)->name() << " = "

++                                    << switchFields.at(i)->switchValue() << Util::lineBreak();

++                             output << Util::indent(1) << "};"

++                                    << Util::lineBreak(2);

++                         }

++                     } else {

++                         if (field->name() == switchFields.at(nextField)->switchField()) {

++                             output << Util::indent(2) << switchFields.at(i)->name() << " = "

++                                    << switchFields.at(i)->switchValue() << ","

++                                    << Util::lineBreak();

++                         } else {

++                             output << Util::indent(2) << switchFields.at(i)->name() << " = "

++                                    << switchFields.at(i)->switchValue() << Util::lineBreak();

++                             output << Util::indent(1) << "};"

++                                    << Util::lineBreak(2);

++                         }

++                     }

++                 }

++             }

++         }

++     }

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeHeaderGetterSetter(const StructuredType *structuredType,

++                                                                QTextStream &output)

++ {

++     QList<Field *> unionMember;

++     QList<Field *> arrayLengthfields;

++     QList<Field *> switchFields;

++

++     const auto typeFields = structuredType->fields();

++

++     for (const auto &possibleMember : typeFields) {

++         for (const auto &field : typeFields) {

++             if (possibleMember->name() == field->lengthField()

++                 && !arrayLengthfields.contains(possibleMember))

++                 arrayLengthfields.push_back(possibleMember);

++             if (field->isUnion() && field->switchField() == possibleMember->name()

++                 && !unionMember.contains(possibleMember))

++                 unionMember.push_back(possibleMember);

++             if (!possibleMember->switchField().isEmpty() && field->name() == possibleMember->switchField())

++                 switchFields.push_back(field);

++         }

++     }

++     for (const auto &field : typeFields) {

++         if (!arrayLengthfields.contains(field) && !(field->isInStructuredTypeBitMask() && !switchFields.contains(field))) {

++             const auto typeName = field->typeNameSecondPart();

++             const auto tmpFunctionName = field->lowerFirstName();

++             if (!unionMember.contains(field)) {

++                 if (StringIdentifier::typeNameDataTypeConverter.contains(field->typeName())) {

++                     if (field->typeName().contains(StringIdentifier::booleanIdentifier)

++                         || field->typeName().contains(StringIdentifier::integerIdentifier)

++                         || field->typeName().contains(StringIdentifier::floatIdentifier)

++                         || field->typeName().contains(StringIdentifier::doubleIdentifier)) {

++                         if (!field->needContainer()) {

++                             output << Util::indent(1)

++                                    << StringIdentifier::typeNameDataTypeConverter.value(

++                                           field->typeName())

++                                    << " " << tmpFunctionName << "() const;"

++                                    << Util::lineBreak();

++                             output << Util::indent(1) << "void set" << field->name() << "("

++                                    << StringIdentifier::typeNameDataTypeConverter.value(

++                                           field->typeName())

++                                    << " " << tmpFunctionName << ");"

++                                    << Util::lineBreak(2);

++                         } else {

++                             output << Util::indent(1) << "QList<"

++                                    << StringIdentifier::typeNameDataTypeConverter.value(

++                                           field->typeName())

++                                    << "> " << tmpFunctionName << "() const;"

++                                    << Util::lineBreak();

++                             output << Util::indent(1) << "void set" << field->name() << "(QList<"

++                                    << StringIdentifier::typeNameDataTypeConverter.value(

++                                           field->typeName())

++                                    << "> " << tmpFunctionName << ");"

++                                    << Util::lineBreak(2);

++                         }

++                     } else {

++                         if (!field->needContainer()) {

++                             output << Util::indent(1)

++                                    << StringIdentifier::typeNameDataTypeConverter.value(

++                                           field->typeName())

++                                    << " " << tmpFunctionName << "() const;"

++                                    << Util::lineBreak();

++                             output << Util::indent(1) << "void set" << field->name() << "(const "

++                                    << StringIdentifier::typeNameDataTypeConverter.value(

++                                           field->typeName())

++                                    << " &" << tmpFunctionName << ");"

++                                    << Util::lineBreak(2);

++                         } else {

++                             output << Util::indent(1) << "QList<"

++                                    << StringIdentifier::typeNameDataTypeConverter.value(

++                                           field->typeName())

++                                    << "> " << tmpFunctionName << "() const;"

++                                    << Util::lineBreak();

++                             output << Util::indent(1) << "void set" << field->name() << "(const QList<"

++                                    << StringIdentifier::typeNameDataTypeConverter.value(

++                                           field->typeName())

++                                    << "> &" << tmpFunctionName << ");"

++                                    << Util::lineBreak(2);

++                         }

++                     }

++                 } else {

++                     bool isPreCoded = false;

++                     for (const auto &preCodedType : StringIdentifier::opcUaPrecodedTypes) {

++                         if (preCodedType.contains(typeName)) {

++                             isPreCoded = true;

++                             if (preCodedType.deEncoderName().isEmpty()) {

++                                 output << Util::indent(1);

++                                 if (field->needContainer())

++                                     output << "QList<";

++                                 output << preCodedType.className();

++                                 if (field->needContainer())

++                                     output << ">";

++                                 output << " " << tmpFunctionName << "() const;"

++                                        << Util::lineBreak();

++                                 output << Util::indent(1) << "void set" << field->name() << "(const ";

++                                 if (field->needContainer())

++                                     output << "QList<";

++                                 output << preCodedType.className();

++                                 if (field->needContainer())

++                                     output << ">";

++                                 output << " &" << tmpFunctionName << ");"

++                                        << Util::lineBreak(2);

++                             } else {

++                                 output << Util::indent(1);

++                                 if (field->needContainer())

++                                     output << "QList<";

++                                 output << preCodedType.deEncoderName();

++                                 if (field->needContainer())

++                                     output << ">";

++                                 output << " " << tmpFunctionName << "() const;"

++                                        << Util::lineBreak();

++                                 output << Util::indent(1) << "void set" << field->name() << "(const ";

++                                 if (field->needContainer())

++                                     output << "QList<";

++                                 output << preCodedType.deEncoderName();

++                                 if (field->needContainer())

++                                     output << ">";

++                                 output << " &" << tmpFunctionName << ");"

++                                        << Util::lineBreak(2);

++                             }

++                             break;

++                         }

++                     }

++

++                     if (!isPreCoded) {

++                         if (field->needContainer()) {

++                             output << Util::indent(1) << "QList <" << m_prefix << typeName << "> "

++                                    << tmpFunctionName << "() const;"

++                                    << Util::lineBreak();

++                             output << Util::indent(1) << "void set" << field->name() << "(const QList <"

++                                    << m_prefix << typeName << "> &" << tmpFunctionName

++                                    << ");"

++                                    << Util::lineBreak(2);

++                         } else {

++                             bool isEnum = false;

++                             for (const auto &enumeratedType : std::as_const(m_enumeratedTypes)) {

++                                 if (enumeratedType->name() == field->typeName().split(':'_L1).at(1))

++                                     isEnum = true;

++                             }

++                             if (isEnum) {

++                                 output << Util::indent(1) << m_prefix << "::" << typeName << " "

++                                        << tmpFunctionName << "() const;"

++                                        << Util::lineBreak();

++                                 output << Util::indent(1) << "void set" << field->name() << "(const " << m_prefix

++                                        << "::" << typeName << " &" << tmpFunctionName << ");"

++                                        << Util::lineBreak(2);

++                             } else {

++                                 output << Util::indent(1) << m_prefix << typeName << " "

++                                        << tmpFunctionName << "() const;"

++                                        << Util::lineBreak();

++                                 output << Util::indent(1) << "void set" << field->name() << "(const " << m_prefix

++                                        << typeName << " &" << tmpFunctionName << ");"

++                                        << Util::lineBreak(2);

++                             }

++                         }

++                     }

++                 }

++             } else { // is union switchfield, create just getter

++                 output << Util::indent(1) << field->name() << " " << tmpFunctionName << "() const;"

++                        << Util::lineBreak();

++                 output << Util::lineBreak();

++             }

++         }

++     }

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeHeaderDebug(const StructuredType *structuredType, QTextStream &output)

++ {

++     output << Util::indent(1) << "friend QDebug operator<<(QDebug debug, const " << m_prefix << structuredType->name() << " &v);";

++     output << Util::lineBreak(2);

++ }

++

++ void DataTypeFileWriter::writeStructuredTypeCppDebug(const StructuredType *structuredType, QTextStream &output)

++ {

++     const auto typeName = u"%1%2"_s.arg(m_prefix, structuredType->name());

++

++     output << "/*!" << Util::lineBreak();

++     output << Util::indent(1) << "Prints the field values of object \\a v to \\a debug" << Util::lineBreak();

++     output << "*/" << Util::lineBreak();

++     output << "QDebug operator<<(QDebug debug, const " << typeName << " &v)" << Util::lineBreak();

++     output << "{" << Util::lineBreak();

++     output << Util::indent(1) << "QDebugStateSaver saver(debug);" << Util::lineBreak();

++     output << Util::indent(1) << "debug.nospace().noquote();" << Util::lineBreak(2);

++     output << Util::indent(1) << "debug << \"" << typeName << " (\";" << Util::lineBreak(2);

++

++     if (!structuredType->hasUnion() && structuredType->hasSwitchfield())

++         output << Util::indent(1) << "bool firstFieldPrinted = false;" << Util::lineBreak(2);

++

++     bool isFirst = true;

++

++     QSet<Field *> lengthFields;

++

++     const auto typeFields = structuredType->fields();

++     for (const auto &field : typeFields) {

++         for (const auto &innerField : typeFields) {

++             if (!field->lengthField().isEmpty() && field->lengthField() == innerField->name())

++                 lengthFields.insert(innerField);

++         }

++     }

++

++     bool parameterUsed = false;

++

++     for (const auto &field : typeFields) {

++         if (structuredType->hasUnion() && field == typeFields.constFirst())

++             continue;

++

++         if (field->isInStructuredTypeBitMask())

++             continue;

++

++         if (lengthFields.contains(field))

++             continue;

++

++         if (structuredType->hasUnion())

++             output << Util::indent(1) << "if (static_cast<quint32>(v." << Util::lowerFirstLetter(field->switchField()) << "()) == " << field->switchValue() << ") {" << Util::lineBreak();

++         else if (!field->switchField().isEmpty())

++             output << Util::indent(1) << "if (v." << Util::lowerFirstLetter(field->switchField()) << "()) {" << Util::lineBreak();

++

++         int indentOffset = 0;

++         if (structuredType->hasUnion() || !field->switchField().isEmpty())

++             indentOffset = 1;

++

++         if (!structuredType->hasUnion() && !isFirst) {

++             if (structuredType->hasSwitchfield())

++                 output << Util::indent(1 + indentOffset) << "if (firstFieldPrinted)" << Util::lineBreak();

++             output << Util::indent(1 + (structuredType->hasSwitchfield() ? indentOffset + 1 : 0)) << "debug << \", \";" << Util::lineBreak();

++         }

++

++         output << Util::indent(1 + indentOffset) << "debug << \"" << field->name() << ": \";" << Util::lineBreak();

++

++         // Not all types have an operator<< for QDebug...

++         const auto isPrecoded = std::find_if(StringIdentifier::opcUaPrecodedTypes.constBegin(), StringIdentifier::opcUaPrecodedTypes.constEnd(),

++                                              [&](const auto &entry) { return entry.name() == field->typeNameSecondPart(); });

++

++         if (isPrecoded == StringIdentifier::opcUaPrecodedTypes.constEnd() || StringIdentifier::precodedTypesWithDebugOperator.contains(field->typeNameSecondPart())) {

++             output << Util::indent(1 + indentOffset) <<  "debug << v." << field->lowerFirstName() << "();" << Util::lineBreak();

++             parameterUsed = true;

++         } else {

++             if (field->needContainer()) {

++                 const auto tempListName = u"%1%2"_s.arg(field->lowerFirstName(), u"Strings"_s);

++                 output << Util::indent(1 + indentOffset) << "QStringList " << tempListName << ";" << Util::lineBreak();

++                 output << Util::indent(1 + indentOffset) << "using namespace Qt::Literals::StringLiterals;" << Util::lineBreak();

++                 output << Util::indent(1 + indentOffset) << "for (int i = 0; i < v." << field->lowerFirstName() << "().size(); ++i)" << Util::lineBreak();

++                 output << Util::indent(2 + indentOffset) << tempListName << ".push_back(u\"" << isPrecoded->className() << "(...)\"_s" << ");" << Util::lineBreak();

++                 output << Util::indent(1 + indentOffset) << "debug << \"QList(\" << " << tempListName << ".join(u\", \"_s) << \")\";";

++                 parameterUsed = true;

++             } else {

++                 output << Util::indent(1 + indentOffset) << "debug << \"" << isPrecoded->className() << "(...)\";";

++             }

++             output << Util::lineBreak();

++         }

++

++         if (!structuredType->hasUnion() && structuredType->hasSwitchfield() && field != typeFields.constLast())

++             output << Util::indent(1 + indentOffset) << "firstFieldPrinted = true;" << Util::lineBreak();

++

++         if (structuredType->hasUnion() || !field->switchField().isEmpty())

++             output << Util::indent(1) << "}" << Util::lineBreak();

++

++         output << Util::lineBreak();

++

++         isFirst = false;

++     }

++

++     if (!parameterUsed)

++         output << Util::lineBreak() << Util::indent(1) << "Q_UNUSED(v);" << Util::lineBreak(2);

++

++     output << Util::indent(1) << "debug << \")\";" << Util::lineBreak();

++     output << Util::indent(1) << "return debug;" << Util::lineBreak();

++     output << "}" << Util::lineBreak();

++ }

++

++ DataTypeFileWriter::GeneratingError DataTypeFileWriter::writeEnumeratedTypes()

++ {

++     QFile file;

++     const auto fileName = u"%1enumerations.h"_s.arg(m_prefix.toLower());

++     QDir dir(m_path);

++     if (!dir.exists(m_path))

++         if (!dir.mkpath(m_path))

++             return UnableToWrite;

++     file.setFileName(dir.absoluteFilePath(fileName));

++     if (!file.open(QIODevice::WriteOnly | QIODevice::Text))

++         return UnableToWrite;

++     QTextStream output(&file);

++     writeLicenseHeader(output);

++

++     if (!m_generatedEnumeratedTypeFilenames.contains(

++             u"%1enumerations"_s.arg(m_prefix.toLower())))

++         m_generatedEnumeratedTypeFilenames.push_back(

++             u"%1enumerations"_s.arg(m_prefix.toLower()));

++     output << "#pragma once"

++            << Util::lineBreak();

++     output << "#include <QMetaType>"

++            << Util::lineBreak(2);

++     output << "namespace " << m_prefix << " {"

++            << Util::lineBreak();

++     output << "Q_NAMESPACE"

++            << Util::lineBreak(2);

++     for (const auto &enumeratedType : std::as_const(m_enumeratedTypes)) {

++         output << "enum class " << enumeratedType->name() << " {" << Util::lineBreak(1);

++         const auto tempValues = enumeratedType->values();

++         for (const auto &enumeratedValue : tempValues) {

++             output << Util::indent(1) << enumeratedValue->name() << " = " << enumeratedValue->value();

++             if (!tempValues.endsWith(enumeratedValue))

++                 output << ",";

++             output << Util::lineBreak();

++         }

++         output << "};"

++                << Util::lineBreak();

++         output << "Q_ENUM_NS(" << enumeratedType->name() << ")"

++                << Util::lineBreak(2);

++     }

++

++     output << Util::lineBreak();

++     output << "}"

++            << Util::lineBreak();

++

++     m_generatedHeaderFileNames.push_back(fileName);

++

++     return GeneratingError::NoError;

++ }

++

++ DataTypeFileWriter::GeneratingError DataTypeFileWriter::generateFile(const XmlElement *type,

++                                                                      const QString &fileExtension)

++ {

++     QFile file;

++     const auto fileName = u"%1%2%3"_s.arg(m_prefix.toLower(),

++                                           type->name().toLower(),

++                                           fileExtension);

++     QDir dir(m_path);

++     if (!dir.exists(m_path))

++         if (!dir.mkpath(m_path))

++             return UnableToWrite;

++     file.setFileName(dir.absoluteFilePath(fileName));

++     if (!file.open(QIODevice::WriteOnly | QIODevice::Text))

++         return UnableToWrite;

++     QTextStream output(&file);

++     writeLicenseHeader(output);

++

++     auto structuredType = dynamic_cast<const StructuredType *>(type);

++     if (structuredType) {

++         if (fileExtension == StringIdentifier::headerIdentifier) {

++             writeStructuredTypeHeader(structuredType, output);

++             if (!m_generatedHeaderFileNames.contains(fileName))

++                 m_generatedHeaderFileNames.push_back(fileName);

++         } else {

++             if (fileExtension == StringIdentifier::cppIdentifier) {

++                 writeStructuredTypeCpp(structuredType, output);

++                 if (!m_generatedSourceFileNames.contains(fileName))

++                     m_generatedSourceFileNames.push_back(fileName);

++             }

++         }

++     }

++     file.close();

++     return NoError;

++ }

++

++ DataTypeFileWriter::GeneratingError DataTypeFileWriter::generateTypes(

++     const QList<XmlElement *> &types)

++ {

++     m_generateMapping.append(types);

++     for (const auto &type : std::as_const(m_generateMapping)) {

++         const auto enumeratedType = dynamic_cast<EnumeratedType *>(type);

++         if (enumeratedType)

++             if (!m_enumeratedTypes.contains(enumeratedType))

++                 m_enumeratedTypes.append(enumeratedType);

++     }

++     if (writeEnumeratedTypes() != GeneratingError::NoError) {

++         return GeneratingError::UnableToWrite;

++     }

++

++     for (const auto &type : std::as_const(m_generateMapping)) {

++         const auto structuredType = dynamic_cast<StructuredType *>(type);

++         if (structuredType) {

++             if (generateFile(type, StringIdentifier::headerIdentifier) != GeneratingError::NoError)

++                 return GeneratingError::UnableToWrite;

++             if (generateFile(type, StringIdentifier::cppIdentifier) != GeneratingError::NoError)

++                 return GeneratingError::UnableToWrite;

++         }

++     }

++     return NoError;

++ }

++

++ QList<XmlElement *> DataTypeFileWriter::generateMapping() const

++ {

++     return m_generateMapping;

++ }

++

++ void DataTypeFileWriter::setGenerateMapping(const QList<XmlElement *> &generateMapping)

++ {

++     m_generateMapping = generateMapping;

++ }

++

++ bool DataTypeFileWriter::writeBundleFiles()

++ {

++     const auto collectionHeaderName = u"%1datatypes%2"_s

++     .arg(m_prefix.toLower(), StringIdentifier::headerIdentifier);

++     const auto collectionSourceName = u"%1datatypes%2"_s

++                                           .arg(m_prefix.toLower(), StringIdentifier::cppIdentifier);

++

++     if (!m_generatedHeaderFileNames.isEmpty()) {

++         QFile file(QDir(m_path).absoluteFilePath(collectionHeaderName));

++         if (!file.open(QFile::WriteOnly))

++             return false;

++

++         QTextStream out(&file);

++

++         writeLicenseHeader(out);

++

++         out << "#pragma once" << Util::lineBreak(2);

++

++         for (const auto &header : std::as_const(m_generatedHeaderFileNames))

++             out << "#include \"" << header << "\"" << Util::lineBreak();

++     }

++

++     const auto enumHeaderCandidate = u"%1enumerations.h"_s.arg(m_prefix.toLower());

++     const bool hasEnums = m_generatedHeaderFileNames.contains(enumHeaderCandidate);

++

++     if (!m_generatedSourceFileNames.isEmpty() || hasEnums) {

++         QFile file(QDir(m_path).absoluteFilePath(collectionSourceName));

++         if (!file.open(QFile::WriteOnly))

++             return false;

++

++         QTextStream out(&file);

++

++         writeLicenseHeader(out);

++

++         if (hasEnums)

++             out << "#include \"" << u"moc_%1enumerations.cpp"_s.arg(m_prefix.toLower()) << "\"" << Util::lineBreak();

++

++         for (const auto &source : std::as_const(m_generatedSourceFileNames))

++             out << "#include \"" << source << "\"" << Util::lineBreak();

++     }

++

++     return true;

++ }

Revision control