Revision control
++ // Copyright (C) 2022 The Qt Company Ltd.
++ // Copyright (C) 2020 Alexey Edelev <semlanik@gmail.com>
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
++ // Qt-Security score:critical reason:data-parser
++
++ #include "generatorcommon.h"
++ #include "options.h"
++ #include "utils.h"
++ #include "commontemplates.h"
++
++ #include "qtprotocdefs.h"
++
++ #ifndef HAVE_PROTOBUF_SYNC_PIPER
++ # include <google/protobuf/descriptor.pb.h>
++ #endif
++
++ #include <array>
++ #include <cassert>
++ #include <string_view>
++
++ using namespace ::google::protobuf;
++ using namespace ::google::protobuf::io;
++ using namespace ::qtprotoccommon;
++
++ namespace {
++ /*
++ Returns the default initializer string for the corresponding field type.
++ */
++ std::string_view getInitializerByFieldType(FieldDescriptor::Type type)
++ {
++ static constexpr std::string_view FloatingPointInitializer = "0.0";
++ static constexpr std::string_view IntegerInitializer = "0";
++ static constexpr std::string_view BoolInitializer = "false";
++ switch (type) {
++ case FieldDescriptor::TYPE_DOUBLE:
++ case FieldDescriptor::TYPE_FLOAT:
++ return FloatingPointInitializer;
++ case FieldDescriptor::TYPE_FIXED32:
++ case FieldDescriptor::TYPE_FIXED64:
++ case FieldDescriptor::TYPE_INT32:
++ case FieldDescriptor::TYPE_INT64:
++ case FieldDescriptor::TYPE_SINT32:
++ case FieldDescriptor::TYPE_SINT64:
++ case FieldDescriptor::TYPE_UINT32:
++ case FieldDescriptor::TYPE_UINT64:
++ return IntegerInitializer;
++ case FieldDescriptor::TYPE_BOOL:
++ return BoolInitializer;
++ default:
++ break;
++ }
++ return {};
++ }
++ } // namespace
++
++ std::set<std::string> common::m_extraNamespacedFiles;
++
++ /*
++ Constructs a C++ namespace from the full protobuf descriptor name. E.g. for
++ the message descriptor "test.protobuf.MessageType" the function
++ returns "test::protobuf", if the separator is "::".
++ */
++ std::string common::getFullNamespace(std::string_view fullDescriptorName,
++ std::string_view separator,
++ bool extraScope)
++ {
++ std::string output = (extraScope) ? Options::instance().extraNamespace() : "";
++ std::string::size_type nameIndex = fullDescriptorName.rfind('.');
++ if (nameIndex == std::string::npos)
++ return output;
++ std::string namespacesStr =
++ utils::replace(fullDescriptorName.substr(0, nameIndex), ".", separator);
++ if (namespacesStr == "QtCore" || namespacesStr == "QtGui")
++ namespacesStr = "QtProtobufPrivate" + std::string(separator) + namespacesStr;
++ if (!output.empty() && !namespacesStr.empty())
++ output += separator;
++ output += namespacesStr;
++ return output;
++ }
++
++ std::string common::buildExportMacro(bool addTrailingSpace)
++ {
++ static const std::string ¯oOption = Options::instance().exportMacro();
++ if (macroOption.empty())
++ return macroOption;
++
++ static std::string macro = "QPB_" + macroOption + "_EXPORT";
++ std::string resultingMacro = macro;
++ if (addTrailingSpace)
++ resultingMacro += ' ';
++ return resultingMacro;
++ }
++ /*
++ Constructs a C++ namespace for wrapping nested message types.
++ E.g. for the message descriptor with name "test.protobuf.MessageType.NestedMessageType" the
++ function returns "test::protobuf::MessageType_QtProtobufNested", if the separator
++ is "::".
++ */
++ std::string common::getNestedNamespace(const Descriptor *type, std::string_view separator)
++ {
++ assert(type != nullptr);
++ std::string namespaces{ type->file()->package() };
++
++ std::string nestingNamespaces;
++ const Descriptor *containingType = type->containing_type();
++ while (containingType) {
++ nestingNamespaces.insert(0,
++ std::string(separator)
++ + utils::capitalizeAsciiName(containingType->name())
++ + CommonTemplates::QtProtobufNestedNamespace());
++ containingType = containingType->containing_type();
++ }
++ if (!nestingNamespaces.empty())
++ namespaces += nestingNamespaces;
++ return utils::replace(namespaces, ".", separator);
++ }
++
++ /*
++ Cuts the prepending 'scope' namespaces from the original string to create the minimum required
++ C++ identifier that can be used inside the scope namespace. Both strings should be C++
++ namespaces separated by double colon.
++ E.g. for the original namespace "test::protobuf" with the "test" scope the function should
++ return "protobuf".
++ */
++ std::string common::getScopeNamespace(std::string_view original, std::string_view scope)
++ {
++ if (scope.empty())
++ return std::string(original);
++
++ if (original == scope)
++ return "";
++
++ std::string scopeWithSeparator;
++ scopeWithSeparator.reserve(scope.size() + 2);
++ scopeWithSeparator += scope;
++ scopeWithSeparator += "::";
++
++ if (utils::startsWith(original, scopeWithSeparator))
++ return std::string(original.substr(scopeWithSeparator.size()));
++
++ return std::string(original);
++ }
++
++ std::map<std::string, std::string> common::getNestedScopeNamespace(const std::string &className)
++ {
++ return { { "scope_namespaces", className + CommonTemplates::QtProtobufNestedNamespace() } };
++ }
++
++ TypeMap common::produceQtTypeMap(const Descriptor *type, const Descriptor *scope)
++ {
++ std::string scopeNamespaces = getScopeNamespace(type, scope);
++ std::string qmlPackage = getFullNamespace(type, ".");
++
++ std::string name{ type->name() };
++ std::string fullName = name;
++ std::string scopeName = name;
++
++ std::string listName = "QList<" + name + ">";
++
++ return { { "type", name },
++ { "full_type", fullName },
++ { "scope_type", scopeName },
++ { "list_type", listName },
++ { "full_list_type", listName },
++ { "scope_list_type", listName },
++ { "scope_namespaces", scopeNamespaces },
++ { "qml_package", qmlPackage },
++ { "property_type", fullName },
++ { "property_list_type", listName },
++ { "getter_type", scopeName },
++ { "setter_type", scopeName } };
++ }
++
++ TypeMap common::produceOverriddenTypeMap(const Descriptor *type, const Descriptor *scope)
++ {
++ std::string namespaces = getFullNamespace(type, "::");
++ std::string qmlPackage = getFullNamespace(type, ".");
++
++ std::string name{ type->name() };
++ std::string listName;
++ if (type->full_name() == "google.protobuf.Any") {
++ namespaces = "QtProtobuf";
++ name = "QtProtobuf::Any";
++ listName = std::string("QList<QtProtobuf::Any>");
++ qmlPackage = "QtProtobuf";
++ } else {
++ listName = std::string("QList<") + name + ">";
++ }
++ const std::string scopeNamespaces =
++ getScopeNamespace(namespaces, getFullNamespace(scope, "::"));
++ const std::string fullName = name;
++ const std::string scopeName = fullName;
++
++ return { { "type", name },
++ { "full_type", fullName },
++ { "scope_type", scopeName },
++ { "list_type", listName },
++ { "full_list_type", listName },
++ { "scope_list_type", listName },
++ { "scope_namespaces", scopeNamespaces },
++ { "qml_package", qmlPackage },
++ { "property_type", fullName },
++ { "property_list_type", listName },
++ { "getter_type", scopeName },
++ { "setter_type", scopeName },
++ { "initializer", "{}" } };
++ }
++
++ TypeMap common::produceMessageTypeMap(const Descriptor *type, const Descriptor *scope)
++ {
++ std::string namespaces = getFullNamespace(type, "::");
++ std::string nestedNamespaces = isNested(type) ? getNestedNamespace(type, "::") : namespaces;
++ std::string scopeNamespaces = getScopeNamespace(type, scope);
++ std::string qmlPackage = getFullNamespace(type, ".");
++ if (qmlPackage.empty())
++ qmlPackage = "QtProtobuf";
++
++ std::string name = utils::capitalizeAsciiName(type->name());
++ std::string fullName = namespaces.empty() ? name : (namespaces + "::" + name);
++ std::string scopeName = scopeNamespaces.empty() ? name : (scopeNamespaces + "::" + name);
++
++ std::string listName = "QList<" + name + ">";
++ std::string fullListName = namespaces.empty() ? listName : "QList<" + fullName + ">";
++ std::string scopeListName = scopeNamespaces.empty() ? listName : "QList<" + scopeName + ">";
++
++ std::string exportMacro = common::buildExportMacro();
++
++ const std::string initializer = "nullptr";
++ return { { "classname", name },
++ { "dataclassname", name + CommonTemplates::DataClassName() },
++ { "classname_low_case", utils::deCapitalizeAsciiName(type->name()) },
++ { "type", name },
++ { "full_type", fullName },
++ { "scope_type", scopeName },
++ { "list_type", listName },
++ { "full_list_type", fullListName },
++ { "scope_list_type", scopeListName },
++ { "scope_namespaces", scopeNamespaces },
++ { "qml_package", qmlPackage },
++ { "property_type", fullName },
++ { "property_list_type", fullListName },
++ { "getter_type", scopeName },
++ { "setter_type", scopeName },
++ { "export_macro", exportMacro },
++ { "initializer", initializer } };
++ }
++
++ TypeMap common::produceEnumTypeMap(const EnumDescriptor *type, const Descriptor *scope)
++ {
++ EnumVisibility visibility = enumVisibility(type, scope);
++ std::string namespaces = getFullNamespace(type, "::");
++
++ std::string name = utils::capitalizeAsciiName(type->name());
++ // qml package should consist only from proto package
++ std::string qmlPackage = getFullNamespace(type, ".");
++ if (qmlPackage.empty())
++ qmlPackage = "QtProtobuf";
++
++ std::string scopeNamespaces = getScopeNamespace(type, scope);
++ std::string enumGadget = scope != nullptr ? utils::capitalizeAsciiName(scope->name()) : "";
++ if (visibility == GLOBAL_ENUM) {
++ enumGadget = name + CommonTemplates::EnumClassSuffix();
++ namespaces += "::";
++ namespaces += enumGadget; // Global enums are stored in helper Gadget
++ scopeNamespaces = getScopeNamespace(namespaces, getFullNamespace(scope, "::"));
++ }
++
++ std::string fullName = namespaces.empty() ? name : (namespaces + "::" + name);
++ std::string scopeName = scopeNamespaces.empty() ? name : (scopeNamespaces + "::" + name);
++
++ std::string listName = "QList<" + name + '>';
++ std::string fullListName = namespaces.empty() ? listName : "QList<" + fullName + '>';
++ std::string scopeListName = scopeNamespaces.empty() ? listName : "QList<" + scopeName + '>';
++
++ // Note: For local enum classes it's impossible to use class name space in Q_PROPERTY
++ // declaration. So please avoid addition of namespaces in line bellow
++ std::string propertyType = visibility == LOCAL_ENUM ? name : fullName;
++ std::string exportMacro = common::buildExportMacro();
++
++ std::string initializer = scopeName + "::" + common::qualifiedCppName(type->value(0)->name());
++ return { { "classname", name },
++ { "classname_low_case", utils::deCapitalizeAsciiName(name) },
++ { "type", name },
++ { "full_type", fullName },
++ { "scope_type", scopeName },
++ { "list_type", listName },
++ { "full_list_type", fullListName },
++ { "scope_list_type", scopeListName },
++ { "scope_namespaces", scopeNamespaces },
++ { "qml_package", qmlPackage },
++ { "property_type", propertyType },
++ { "property_list_type", fullListName },
++ { "getter_type", scopeName },
++ { "setter_type", scopeName },
++ { "enum_gadget", enumGadget },
++ { "export_macro", exportMacro },
++ { "initializer", initializer } };
++ }
++
++ TypeMap common::produceSimpleTypeMap(FieldDescriptor::Type type)
++ {
++ std::string namespaces;
++ if (type != FieldDescriptor::TYPE_STRING && type != FieldDescriptor::TYPE_BYTES
++ && type != FieldDescriptor::TYPE_BOOL && type != FieldDescriptor::TYPE_FLOAT
++ && type != FieldDescriptor::TYPE_DOUBLE) {
++ namespaces = CommonTemplates::QtProtobufNamespace();
++ }
++
++ std::string name;
++ std::string qmlPackage = CommonTemplates::QtProtobufNamespace();
++
++ auto it = CommonTemplates::TypeReflection().find(type);
++ if (it != std::end(CommonTemplates::TypeReflection()))
++ name = it->second;
++ else
++ assert(name.empty());
++
++ std::string fullName = namespaces.empty() ? name : (namespaces + "::" + name);
++ std::string listName = name + "List";
++ using namespace std::string_literals;
++ std::string fullListName = listName;
++ if (type != FieldDescriptor::TYPE_STRING && type != FieldDescriptor::TYPE_BYTES)
++ fullListName = CommonTemplates::QtProtobufNamespace() + "::"s + listName;
++ std::string scopeListName = fullListName;
++ const std::string initializer(getInitializerByFieldType(type));
++ return { { "type", name },
++ { "full_type", fullName },
++ { "scope_type", fullName },
++ { "list_type", listName },
++ { "full_list_type", fullListName },
++ { "scope_list_type", scopeListName },
++ { "scope_namespaces", namespaces },
++ { "qml_package", qmlPackage },
++ { "property_type", fullName },
++ { "property_list_type", fullListName },
++ { "getter_type", fullName },
++ { "setter_type", fullName },
++ { "initializer", initializer } };
++ }
++
++ MethodMap common::produceMethodMap(const MethodDescriptor *method, const std::string &scope)
++ {
++ std::string inputTypeName{ utils::replace(method->input_type()->full_name(), ".", "::") };
++ std::string outputTypeName{ utils::replace(method->output_type()->full_name(), ".", "::") };
++ std::string methodName{ method->name() };
++ std::string methodNameUpper{ method->name() };
++ methodNameUpper[0] = static_cast<char>(utils::toAsciiUpper(methodNameUpper[0]));
++
++ std::string senderName = std::move(methodNameUpper) + "Sender";
++
++ std::string serviceName{ method->service()->name() };
++
++ //Make sure that we don't clash the same stream names from different services
++ std::string senderQmlName = serviceName;
++ senderQmlName += senderName;
++
++ std::string streamType;
++ if (method->client_streaming() && method->server_streaming()) {
++ streamType = "Bidi";
++ } else if (method->server_streaming()) {
++ streamType = "Server";
++ } else if (method->client_streaming()) {
++ streamType = "Client";
++ }
++
++ std::string streamTypeLower = utils::deCapitalizeAsciiName(streamType);
++
++ static const std::string exportMacro = common::buildExportMacro();
++
++ return {
++ {"classname", scope },
++ { "sender_class_name", senderName },
++ { "sender_qml_name", senderQmlName },
++ { "return_type", outputTypeName },
++ { "classname_low_case", utils::deCapitalizeAsciiName(scope)},
++ { "method_name", methodName },
++ { "param_type", inputTypeName },
++ { "param_name", "arg" },
++ { "stream_type", streamType },
++ { "stream_type_lower", streamTypeLower },
++ { "return_name", "ret" },
++ { "export_macro", exportMacro },
++ { "service_name", serviceName },
++ };
++ }
++
++ TypeMap common::produceServiceTypeMap(const ServiceDescriptor *service, const Descriptor *scope)
++ {
++ const std::string name{ "Service" };
++ const std::string fullName{ "Service" };
++ const std::string scopeName{ service->name() };
++ static const std::string exportMacro = common::buildExportMacro();
++
++ const std::string namespaces = getFullNamespace(service, "::");
++ const std::string scopeNamespaces = getScopeNamespace(namespaces,
++ getFullNamespace(scope, "::"));
++
++ return { { "classname", name },
++ { "classname_low_case", utils::deCapitalizeAsciiName(name) },
++ { "full_type", fullName },
++ { "scope_type", scopeName },
++ { "scope_namespaces", scopeNamespaces },
++ { "parent_class", "QAbstractGrpcService" },
++ { "export_macro", exportMacro } };
++ }
++
++ TypeMap common::produceClientTypeMap(const ServiceDescriptor *service, const Descriptor *scope)
++ {
++ const std::string name{ "Client" };
++ const std::string fullName{ "Client" };
++ const std::string scopeName{ service->name() };
++ static const std::string exportMacro = common::buildExportMacro();
++
++ const std::string namespaces = getFullNamespace(service, "::");
++ const std::string scopeNamespaces = getScopeNamespace(namespaces,
++ getFullNamespace(scope, "::"));
++
++ const std::string serviceName{ service->full_name() };
++ return { { "classname", name },
++ { "classname_low_case", utils::deCapitalizeAsciiName(name) },
++ { "full_type", fullName },
++ { "scope_type", scopeName },
++ { "scope_namespaces", scopeNamespaces },
++ { "parent_class", "QGrpcClientBase" },
++ { "service_name", serviceName },
++ { "export_macro", exportMacro } };
++ }
++
++ TypeMap common::produceQmlClientTypeMap(const ServiceDescriptor *service, const Descriptor *scope)
++ {
++ const std::string name{ "QmlClient" };
++ const std::string fullName{ "QmlClient" };
++ const std::string serviceName{ service->name() };
++ static const std::string exportMacro = common::buildExportMacro();
++
++ const std::string namespaces = getFullNamespace(service, "::");
++ const std::string scopeNamespaces = getScopeNamespace(namespaces,
++ getFullNamespace(scope, "::"));
++
++ return { { "classname", name },
++ { "classname_low_case", utils::deCapitalizeAsciiName(name) },
++ { "full_type", fullName },
++ { "scope_type", serviceName },
++ { "service_name", serviceName },
++ { "scope_namespaces", scopeNamespaces },
++ { "parent_class", "Client" },
++ { "export_macro", exportMacro } };
++ }
++
++ bool common::isQtType(const FieldDescriptor *field)
++ {
++ const auto fullName = field->message_type()->full_name();
++ const auto package = field->file()->package();
++ return (utils::startsWith(fullName, "QtCore.") || utils::startsWith(fullName, "QtGui."))
++ && package != "QtCore" && package != "QtGui";
++ }
++
++ bool common::isOverridden(const FieldDescriptor *field)
++ {
++ return field->type() == FieldDescriptor::TYPE_MESSAGE
++ && field->message_type()->full_name() == "google.protobuf.Any";
++ }
++
++ bool common::isPureMessage(const FieldDescriptor *field)
++ {
++ return field->type() == FieldDescriptor::TYPE_MESSAGE && !field->is_map()
++ && !field->is_repeated() && !common::isQtType(field) && !common::isOverridden(field);
++ }
++
++ bool common::isRepeatedMessage(const FieldDescriptor *field)
++ {
++ return field->type() == FieldDescriptor::TYPE_MESSAGE
++ && !field->is_map() && field->is_repeated();
++ }
++
++ // Groups use their own wire encoding, which QtProtobuf does not implement, so no
++ // code is generated for them. Every place that derives field indices or metadata
++ // offsets must skip them the same way or the two disagree.
++ bool common::isGroupField(const FieldDescriptor *field)
++ {
++ return field->type() == FieldDescriptor::TYPE_GROUP;
++ }
++
++ int common::generatedFieldCount(const Descriptor *message)
++ {
++ int count = 0;
++ const int numFields = message->field_count();
++ for (int i = 0; i < numFields; ++i) {
++ if (!isGroupField(message->field(i)))
++ ++count;
++ }
++ return count;
++ }
++
++ void common::iterateMessageFields(const Descriptor *message, const IterateMessageLogic &callback)
++ {
++ int numFields = message->field_count();
++ for (int i = 0; i < numFields; ++i) {
++ const FieldDescriptor *field = message->field(i);
++ if (isGroupField(field))
++ continue;
++ auto propertyMap = common::producePropertyMap(field, message);
++ callback(field, propertyMap);
++ }
++ }
++
++ void common::iterateOneofFields(const Descriptor *message, const IterateOneofCallback &callback)
++ {
++ int numFields =
++ #ifdef HAVE_REAL_ONEOF_DECL
++ message->real_oneof_decl_count();
++ #else
++ message->oneof_decl_count();
++ #endif
++
++ for (int i = 0; i < numFields; ++i) {
++ const OneofDescriptor *field =
++ #ifdef HAVE_REAL_ONEOF_DECL
++ message->real_oneof_decl(i);
++ #else
++ message->oneof_decl(i);
++ #endif
++ #if defined(HAVE_PROTOBUF_SYNC_PIPER) && !defined(HAVE_REAL_ONEOF_DECL)
++ if (field->is_synthetic())
++ continue;
++ #endif
++ auto propertyMap = common::producePropertyMap(field, message);
++ callback(field, propertyMap);
++ }
++ }
++
++ TypeMap common::produceTypeMap(const FieldDescriptor *field, const Descriptor *scope)
++ {
++ assert(field != nullptr);
++
++ switch (field->type()) {
++ case FieldDescriptor::TYPE_MESSAGE:
++ if (isQtType(field))
++ return produceQtTypeMap(field->message_type(), nullptr);
++ if (isOverridden(field))
++ return produceOverriddenTypeMap(field->message_type(), nullptr);
++ return produceMessageTypeMap(field->message_type(), scope);
++ case FieldDescriptor::TYPE_ENUM:
++ return produceEnumTypeMap(field->enum_type(), scope);
++ default:
++ break;
++ }
++
++ return produceSimpleTypeMap(field->type());
++ }
++
++ PropertyMap common::producePropertyMap(const OneofDescriptor *oneof, const Descriptor *scope)
++ {
++ assert(oneof != nullptr);
++ assert(scope != nullptr);
++
++ PropertyMap propertyMap;
++ propertyMap["optional_property_name"] = qualifiedCppName(qualifiedQmlName(oneof->name()));
++ propertyMap["optional_property_name_cap"] = utils::capitalizeAsciiName(oneof->name());
++ auto scopeTypeMap = produceMessageTypeMap(scope, nullptr);
++ propertyMap["classname"] = scopeTypeMap["classname"];
++ propertyMap["dataclassname"] = propertyMap["classname"] + CommonTemplates::DataClassName();
++ propertyMap["type"] = propertyMap["optional_property_name_cap"] + "Fields";
++ propertyMap["export_macro"] = common::buildExportMacro();
++
++ return propertyMap;
++ }
++
++ PropertyMap common::producePropertyMap(const FieldDescriptor *field, const Descriptor *scope)
++ {
++ assert(field != nullptr);
++ assert(scope != nullptr);
++
++ PropertyMap propertyMap = produceTypeMap(field, scope);
++
++ std::string scriptable = "true";
++ if (!field->is_map() && !field->is_repeated()
++ && (field->type() == FieldDescriptor::TYPE_INT64
++ || field->type() == FieldDescriptor::TYPE_SINT64
++ || field->type() == FieldDescriptor::TYPE_FIXED64
++ || field->type() == FieldDescriptor::TYPE_SFIXED64)) {
++ scriptable = "false";
++ }
++
++ std::string propertyName = qualifiedCppName(
++ qualifiedQmlName(utils::deCapitalizeAsciiName(field->camelcase_name())));
++ std::string propertyNameCap = utils::capitalizeAsciiName(propertyName);
++
++ propertyMap["property_name"] = propertyName;
++ propertyMap["property_name_cap"] = propertyNameCap;
++ propertyMap["mutable_getter_name"] = CommonTemplates::MutableGetterPrefix();
++ propertyMap["mutable_getter_name"] += propertyNameCap;
++
++ propertyMap["scriptable"] = scriptable;
++ propertyMap["export_macro"] = common::buildExportMacro();
++
++ auto scopeTypeMap = produceMessageTypeMap(scope, nullptr);
++ propertyMap["key_type"] = "";
++ propertyMap["value_type"] = "";
++ propertyMap["classname"] = scopeTypeMap["classname"];
++ propertyMap["dataclassname"] = propertyMap["classname"] + CommonTemplates::DataClassName();
++ propertyMap["number"] = std::to_string(field->number());
++
++ if (common::isOneofField(field)) {
++ propertyMap["optional_property_name"] =
++ qualifiedCppName(qualifiedQmlName(field->containing_oneof()->name()));
++ propertyMap["optional_property_name_cap"] =
++ utils::capitalizeAsciiName(field->containing_oneof()->name());
++ } else if (common::isOptionalField(field)) {
++ propertyMap["optional_property_name"] = propertyName;
++ propertyMap["optional_property_name_cap"] = propertyNameCap;
++ }
++
++ if (field->is_map()) {
++ const Descriptor *type = field->message_type();
++ auto keyMap = common::producePropertyMap(type->field(0), scope);
++ auto valueMap = common::producePropertyMap(type->field(1), scope);
++ propertyMap["key_type"] = keyMap["scope_type"];
++ propertyMap["value_type"] = valueMap["scope_type"];
++ propertyMap["value_list_type"] = valueMap["scope_list_type"];
++ } else if (field->is_repeated()) {
++ propertyMap["getter_type"] = propertyMap["scope_list_type"];
++ propertyMap["setter_type"] = propertyMap["scope_list_type"];
++ }
++
++ return propertyMap;
++ }
++
++ std::string common::qualifiedCppName(std::string_view name)
++ {
++ return utils::contains(CommonTemplates::ListOfCppExceptions(), name) ? std::string{ name } + "_"
++ : std::string{ name };
++ }
++
++ std::string common::qualifiedQmlName(std::string_view name)
++ {
++ std::string fieldName(name);
++ const std::vector<std::string> &searchExceptions = CommonTemplates::ListOfQmlExceptions();
++
++ if (utils::contains(searchExceptions, fieldName))
++ return fieldName.append(CommonTemplates::ProtoSuffix());
++ return fieldName;
++ }
++
++ bool common::isOneofField(const FieldDescriptor *field)
++ {
++ #ifdef HAVE_PROTOBUF_SYNC_PIPER
++ return field->real_containing_oneof() != nullptr;
++ #else
++ return field->containing_oneof() != nullptr;
++ #endif
++ }
++
++ bool common::isTriviallyCopyable(const FieldDescriptor *field)
++ {
++ return !field->is_repeated() &&
++ field->type() != FieldDescriptor::TYPE_MESSAGE &&
++ field->type() != FieldDescriptor::FieldDescriptor::TYPE_STRING &&
++ field->type() != FieldDescriptor::FieldDescriptor::TYPE_BYTES;
++ }
++
++ bool common::isOptionalField(const FieldDescriptor *field)
++ {
++ #ifdef HAVE_PROTOBUF_SYNC_PIPER
++ // required fields report explicit presence too, so exclude them here.
++ bool hasOptional = field->has_presence() && !field->real_containing_oneof()
++ && !field->is_required();
++ #else
++ bool hasOptional = field->file()->syntax() == FileDescriptor::SYNTAX_PROTO2
++ && field->is_optional() && !field->containing_oneof();
++ #endif
++ return field->type() != FieldDescriptor::TYPE_MESSAGE && hasOptional;
++ }
++
++ bool common::isLocalEnum(const EnumDescriptor *type, const Descriptor *scope)
++ {
++ assert(type != nullptr);
++
++ return scope != nullptr && type->containing_type() == scope;
++ }
++
++ common::EnumVisibility common::enumVisibility(const EnumDescriptor *type, const Descriptor *scope)
++ {
++ assert(type != nullptr);
++
++ if (type->containing_type() == nullptr)
++ return GLOBAL_ENUM;
++
++ if (isLocalEnum(type, scope)) {
++ return LOCAL_ENUM;
++ }
++
++ return NEIGHBOR_ENUM;
++ }
++
++ bool common::hasQmlAlias(const FieldDescriptor *field)
++ {
++ return !field->is_map() && !field->is_repeated()
++ && (field->type() == FieldDescriptor::TYPE_INT32
++ || field->type() == FieldDescriptor::TYPE_SFIXED32
++ || field->type() == FieldDescriptor::TYPE_FIXED32)
++ && Options::instance().hasQml();
++ }
++
++ bool common::hasNestedTypes(const Descriptor *type)
++ {
++ return common::hasNestedMessages(type) || type->enum_type_count() > 0
++ || Options::instance().generateFieldEnum() || type->oneof_decl_count() > 0;
++ }
++
++ void common::iterateMessages(const FileDescriptor *file,
++ const std::function<void(const Descriptor *)> &callback)
++ {
++ int numMessageTypes = file->message_type_count();
++ for (int i = 0; i < numMessageTypes; ++i)
++ callback(file->message_type(i));
++ }
++
++ void common::iterateNestedMessages(const Descriptor *message,
++ const std::function<void(const Descriptor *)> &callback)
++ {
++ int numNestedTypes = message->nested_type_count();
++ for (int i = 0; i < numNestedTypes; ++i) {
++ const Descriptor *nestedMessage = message->nested_type(i);
++ if (!isMap(nestedMessage)) {
++ callback(nestedMessage);
++ continue;
++ }
++ }
++ }
++
++ bool common::hasNestedMessages(const Descriptor *message)
++ {
++ int numNestedTypes = message->nested_type_count();
++ if (numNestedTypes > 0 && message->field_count() == 0)
++ return true;
++
++ for (int i = 0; i < numNestedTypes; ++i) {
++ const Descriptor *nestedMessage = message->nested_type(i);
++ if (!isMap(nestedMessage))
++ return true;
++ }
++
++ return false;
++ }
++
++ bool common::isNested(const Descriptor *message)
++ {
++ if (message->containing_type() == nullptr)
++ return false;
++
++ const Descriptor *containingType = message->containing_type();
++
++ int numFields = containingType->field_count();
++ for (int i = 0; i < numFields; ++i) {
++ const FieldDescriptor *field = containingType->field(i);
++ if (field->message_type() == message) {
++ return !field->is_map();
++ }
++ }
++
++ return true;
++ }
++
++ bool common::isMap(const Descriptor *message)
++ {
++ assert(message != nullptr);
++ #ifdef HAVE_PROTOBUF_SYNC_PIPER
++ return message->map_key() != nullptr;
++ #else
++ return message->options().map_entry();
++ #endif
++ }
++
++ const Descriptor *common::findHighestMessage(const Descriptor *message)
++ {
++ const Descriptor *highestMessage = message;
++ while (highestMessage->containing_type() != nullptr)
++ highestMessage = highestMessage->containing_type();
++ return highestMessage;
++ }
++
++ std::string common::collectFieldFlags(const FieldDescriptor *field)
++ {
++ constexpr std::string_view flagsConstuctor = "uint(";
++ std::string_view separator = " | ";
++ std::string_view active_separator;
++ std::string flags(flagsConstuctor);
++
++ auto writeFlag = [&](const char *flag) {
++ flags += active_separator;
++ flags += "QtProtobufPrivate::FieldFlag::";
++ flags += flag;
++ active_separator = separator;
++ };
++
++ if (field->type() != FieldDescriptor::TYPE_STRING
++ && field->type() != FieldDescriptor::TYPE_BYTES
++ && field->type() != FieldDescriptor::TYPE_MESSAGE
++ && !field->is_map() && field->is_repeated()
++ && !field->is_packed()) {
++ writeFlag("NonPacked");
++ }
++
++ if (common::isOneofField(field))
++ writeFlag("Oneof");
++
++ if (common::isOptionalField(field))
++ writeFlag("Optional");
++
++ if (field->is_required())
++ writeFlag("Required");
++
++ if (common::isOneofField(field) || common::isOptionalField(field)
++ || common::isPureMessage(field)) {
++ writeFlag("ExplicitPresence");
++ }
++
++ if (field->is_map())
++ writeFlag("Map");
++
++ if (field->is_repeated() && !field->is_map())
++ writeFlag("Repeated");
++
++ if (field->type() == FieldDescriptor::TYPE_ENUM)
++ writeFlag("Enum");
++
++ if (field->type() == FieldDescriptor::TYPE_MESSAGE)
++ writeFlag("Message");
++
++ if (flags == flagsConstuctor)
++ writeFlag("NoFlags");
++ flags += ")";
++ return flags;
++ }
++
++ bool common::isExtraNamespacedFile(std::string_view file)
++ {
++ return m_extraNamespacedFiles.find(std::string{ file }) != m_extraNamespacedFiles.end();
++ }
++
++ void common::setExtraNamespacedFiles(const std::set<std::string> &files)
++ {
++ if (!files.empty() && files != m_extraNamespacedFiles)
++ m_extraNamespacedFiles = files;
++ }
++
++ std::string common::headerGuardFromFilename(std::string fileName)
++ {
++ utils::asciiToUpper(fileName);
++ return utils::replace(fileName, ".", "_");
++ }
++
++ std::string common::generateRelativeFilePath(const FileDescriptor *file, const std::string &name)
++ {
++ std::string outFileBasename;
++ if (Options::instance().isFolder()) {
++ outFileBasename = file->package();
++ if (!outFileBasename.empty()) {
++ outFileBasename = utils::replace(outFileBasename, ".", "/");
++ outFileBasename += '/';
++ }
++ }
++ outFileBasename += name;
++
++ return outFileBasename;
++ }
++
++ bool common::hasCustomJsonCoversion(const Descriptor *message)
++ {
++ static constexpr std::array<std::string_view, 11> TypesSupportingOptionalCoversion{
++ "Timestamp", "Duration", "BoolValue", "Int32Value", "Int64Value", "UInt32Value",
++ "UInt64Value", "FloatValue", "DoubleValue", "BytesValue", "StringValue",
++ };
++
++ return std::find(TypesSupportingOptionalCoversion.begin(),
++ TypesSupportingOptionalCoversion.end(), std::string_view(message->name()))
++ != TypesSupportingOptionalCoversion.end();
++ }