Rename List suffix for generated messages

examples/addressbook/addressbookengine.h

@@ -68,7 +68,7 @@ signals:
 private:
     qtprotobuf::examples::AddressBookClient *m_client;
     ContactsListModel *m_contacts;
-    qtprotobuf::examples::ContactList m_container;
+    qtprotobuf::examples::ContactRepeated m_container;
     qtprotobuf::examples::CallStatus m_callStatus;
 };
 

src/generator/classgeneratorbase.cpp

@@ -142,7 +142,7 @@ std::string ClassGeneratorBase::getTypeName(const FieldDescriptor *field, const
             return mClassName + "::" + field->message_type()->name();
         }
         if (field->is_repeated()) {
-            return namespaceTypeName.append("List");
+            return namespaceTypeName.append(Templates::ListSuffix);
         }
     } else if (field->type() == FieldDescriptor::TYPE_ENUM) {
         const EnumDescriptor *enumType = field->enum_type();
@@ -162,7 +162,7 @@ std::string ClassGeneratorBase::getTypeName(const FieldDescriptor *field, const
             typeName = namespaceTypeName.append(enumType->name());
         }
         if (field->is_repeated()) {
-            return typeName.append("List");
+            return typeName.append(Templates::ListSuffix);
         }
     } else {
         auto it = Templates::TypeReflection.find(field->type());

src/generator/globalenumssourcegenerator.cpp

@@ -83,7 +83,7 @@ void GlobalEnumsSourceGenerator::printRegisterBody(const std::list<const FileDes
             const auto enumDescr = file->enum_type(i);
             const std::map<std::string, std::string> properties = {{"classname", mClassName},
                                                                    {"type", mClassName + "::" + enumDescr->name()},
-                                                                   {"enum", enumDescr->name() + "List"},
+                                                                   {"enum", enumDescr->name() + Templates::ListSuffix},
                                                                    {"namespaces", fullNamespace}};
             mPrinter.Print(properties, Templates::ComplexGlobalEnumFieldRegistrationTemplate);
             mPrinter.Print(properties, Templates::RegisterMetaTypeTemplate);

src/generator/protobufclassgenerator.cpp

@@ -247,7 +247,12 @@ bool ProtobufClassGenerator::producePropertyMap(const FieldDescriptor *field, Pr
 
     std::string typeNameNoList = typeName;
     if (field->is_repeated() && !field->is_map()) {
-        typeNameNoList.resize(typeNameNoList.size() - strlen("List"));
+        if(field->type() == FieldDescriptor::TYPE_MESSAGE
+                || field->type() == FieldDescriptor::TYPE_ENUM) {
+            typeNameNoList.resize(typeNameNoList.size() - strlen(Templates::ListSuffix));
+        } else {
+            typeNameNoList.resize(typeNameNoList.size() - strlen("List"));
+        }
     }
     propertyMap = {{"type", typeName},
                    {"type_lower", typeNameLower},
@@ -351,7 +356,7 @@ void ProtobufClassGenerator::printLocalEmumsMetaTypesDeclaration()
 
         if (field->type() == FieldDescriptor::TYPE_ENUM
                 && isLocalMessageEnum(mMessage, field)) {
-             mPrinter.Print({{"classname", mClassName + "::" + field->enum_type()->name() + "List"},
+             mPrinter.Print({{"classname", mClassName + "::" + field->enum_type()->name() + Templates::ListSuffix},
                              {"namespaces", mNamespacesColonDelimited}}, Templates::DeclareMetaTypeTemplate);
         }
     }

src/generator/protobufsourcegenerator.cpp

@@ -56,10 +56,10 @@ void ProtobufSourceGenerator::printRegisterBody()
         const FieldDescriptor *field = mMessage->field(i);
         if (field->type() == FieldDescriptor::TYPE_ENUM
                 && isLocalMessageEnum(mMessage, field)) {
-            mPrinter.Print({{"type", mClassName + "::" + field->enum_type()->name() + "List"},
+            mPrinter.Print({{"type", mClassName + "::" + field->enum_type()->name() + Templates::ListSuffix},
                             {"namespaces", mNamespacesColonDelimited}},
                            Templates::RegisterMetaTypeTemplateNoNamespace);
-            mPrinter.Print({{"type", mClassName + "::" + field->enum_type()->name() + "List"},
+            mPrinter.Print({{"type", mClassName + "::" + field->enum_type()->name() + Templates::ListSuffix},
                             {"namespaces", mNamespacesColonDelimited}},
                            Templates::RegisterMetaTypeTemplate);
             mPrinter.Print({{"type", mClassName + "::" + field->enum_type()->name()}},

src/generator/templates.cpp

@@ -49,18 +49,18 @@ const char *Templates::UsingQtProtobufNamespaceTemplate = "\nusing namespace QtP
 const char *Templates::ComplexTypeRegistrationTemplate = "namespace $classname$Private {\n"
                                                          "void registerTypes()\n{\n"
                                                          "    qRegisterMetaType<$classname$>(\"$classname$\");\n"
-                                                         "    qRegisterMetaType<$classname$List>(\"$classname$List\");\n"
+                                                         "    qRegisterMetaType<$classname$Repeated>(\"$classname$Repeated\");\n"
                                                          "    qRegisterMetaType<$classname$>(\"$namespaces$::$classname$\");\n"
-                                                         "    qRegisterMetaType<$classname$List>(\"$namespaces$::$classname$List\");\n"
+                                                         "    qRegisterMetaType<$classname$Repeated>(\"$namespaces$::$classname$Repeated\");\n"
                                                          "";
 const char *Templates::ComplexGlobalEnumRegistrationTemplate = "namespace $classname$Private {\n"
                                                                "void registerTypes()\n{\n";
 const char *Templates::ComplexGlobalEnumFieldRegistrationTemplate = "qRegisterMetaType<$classname$::$enum$>(\"$namespaces$::$classname$::$enum$\");\n";
-const char *Templates::ComplexListTypeUsingTemplate = "using $classname$List = QList<QSharedPointer<$classname$>>;\n";
+const char *Templates::ComplexListTypeUsingTemplate = "using $classname$Repeated = QList<QSharedPointer<$classname$>>;\n";
 const char *Templates::MapTypeUsingTemplate = "using $classname$ = QMap<$key$, $value$>;\n";
 const char *Templates::MessageMapTypeUsingTemplate = "using $classname$ = QMap<$key$, QSharedPointer<$value$>>;\n";
 
-const char *Templates::EnumTypeUsingTemplate = "using $enum$List = QList<$enum$>;\n";
+const char *Templates::EnumTypeUsingTemplate = "using $enum$Repeated = QList<$enum$>;\n";
 
 const char *Templates::NamespaceTemplate = "\nnamespace $namespace$ {\n";
 const char *Templates::UsingNamespaceTemplate = "using namespace $namespace$;\n";
@@ -163,11 +163,11 @@ const char *Templates::PropertyInitializerTemplate = "\n    , m_$property_name$(
 const char *Templates::ConstructorContentTemplate = "\n{\n}\n";
 
 const char *Templates::DeclareMetaTypeTemplate = "Q_DECLARE_METATYPE($namespaces$::$classname$)\n";
-const char *Templates::DeclareMetaTypeListTemplate = "Q_DECLARE_METATYPE($namespaces$::$classname$List)\n";
+const char *Templates::DeclareMetaTypeListTemplate = "Q_DECLARE_METATYPE($namespaces$::$classname$Repeated)\n";
 const char *Templates::DeclareMessageMetaTypeTemplate = "Q_DECLARE_METATYPE($namespaces$::$classname$)\n"
                                                         "Q_DECLARE_OPAQUE_POINTER($namespaces$::$classname$)\n";
 
-const char *Templates::DeclareComplexListTypeTemplate = "Q_DECLARE_METATYPE($namespaces$::$classname$List)\n"
+const char *Templates::DeclareComplexListTypeTemplate = "Q_DECLARE_METATYPE($namespaces$::$classname$Repeated)\n"
                                                         "Q_DECLARE_METATYPE(QQmlListProperty<$namespaces$::$classname$>)\n";
 const char *Templates::RegisterMetaTypeDefaultTemplate = "qRegisterMetaType<$namespaces$::$type$>();\n";
 const char *Templates::RegisterMetaTypeTemplateNoNamespace = "qRegisterMetaType<$namespaces$::$type$>(\"$type$\");\n";
@@ -228,6 +228,9 @@ const char *Templates::ClientMethodServerStream2DefinitionTemplate = "void $clas
                                                                      "    subscribe(\"$method_name$\", $param_name$, &$classname$::$method_name$Updated);\n"
                                                                      "}\n";
 
+const char *Templates::ListSuffix = "Repeated";
+
+
 const std::unordered_map<::google::protobuf::FieldDescriptor::Type, std::string> Templates::TypeReflection = {
     {::google::protobuf::FieldDescriptor::TYPE_DOUBLE, "double"},
     {::google::protobuf::FieldDescriptor::TYPE_FLOAT, "float"},

src/generator/templates.h

@@ -133,6 +133,7 @@ public:
     static const char *ClientMethodServerStreamDefinitionTemplate;
     static const char *ClientMethodServerStream2DefinitionTemplate;
 
+    static const char *ListSuffix;
 
     static const std::unordered_map<::google::protobuf::FieldDescriptor::Type, std::string> TypeReflection;
 };

tests/test_protobuf/deserializationtest.cpp

@@ -914,7 +914,7 @@ TEST_F(DeserializationTest, SimpleEnumListMessageTest)
     ASSERT_TRUE(msg.localEnumList().isEmpty());
 
     msg.deserialize(serializer.get(), QByteArray::fromHex("0a06000102010203"));
-    ASSERT_TRUE((msg.localEnumList() == SimpleEnumListMessage::LocalEnumList {SimpleEnumListMessage::LOCAL_ENUM_VALUE0,
+    ASSERT_TRUE((msg.localEnumList() == SimpleEnumListMessage::LocalEnumRepeated {SimpleEnumListMessage::LOCAL_ENUM_VALUE0,
                 SimpleEnumListMessage::LOCAL_ENUM_VALUE1,
                 SimpleEnumListMessage::LOCAL_ENUM_VALUE2,
                 SimpleEnumListMessage::LOCAL_ENUM_VALUE1,

tests/test_protobuf/serializationtest.cpp

@@ -1467,7 +1467,7 @@ TEST_F(SerializationTest, RepeatedStringMessageTest)
     test.setTestRepeatedString({"aaaa","bbbbb","ccc","dddddd","eeeee", ""});
     QByteArray result = test.serialize(serializer.get());
     //qDebug() << "result " << result.toHex();
-    ASSERT_TRUE(result == QByteArray::fromHex("0a04616161610a0562626262620a036363630a066464646464640a0565656565650a00"));
+    ASSERT_STREQ(result.toHex().toStdString().c_str(), "0a04616161610a0562626262620a036363630a066464646464640a0565656565650a00");
 
     test.setTestRepeatedString(QStringList());
     result = test.serialize(serializer.get());
@@ -1507,7 +1507,7 @@ TEST_F(SerializationTest, RepeatedBytesMessageTest)
                                QByteArray::fromHex("010203040506")});
     result = test.serialize(serializer.get());
     //qDebug() << "result " << result.toHex();
-    ASSERT_TRUE(result == QByteArray::fromHex("0a060102030405060a000a05eaeaeaeaea0a06010203040506"));
+    ASSERT_STREQ(result.toHex().toStdString().c_str(), "0a060102030405060a000a05eaeaeaeaea0a06010203040506");
 }
 
 TEST_F(SerializationTest, RepeatedFloatMessageTest)

tests/test_protobuf/simpletest.cpp

@@ -285,16 +285,16 @@ TEST_F(SimpleTest, SimpleLocalEnumListTest)
     ASSERT_GT(SimpleEnumListMessage::staticMetaObject.enumeratorCount(), 0);
 
     const char *propertyName = "localEnumList";
-    assertMessagePropertyRegistered<SimpleEnumListMessage, SimpleEnumListMessage::LocalEnumList>(1,  "SimpleEnumListMessage::LocalEnumList", propertyName);
+    assertMessagePropertyRegistered<SimpleEnumListMessage, SimpleEnumListMessage::LocalEnumRepeated>(1,  "SimpleEnumListMessage::LocalEnumRepeated", propertyName);
 
-    SimpleEnumListMessage::LocalEnumList value({SimpleEnumListMessage::LOCAL_ENUM_VALUE2,
+    SimpleEnumListMessage::LocalEnumRepeated value({SimpleEnumListMessage::LOCAL_ENUM_VALUE2,
                                                 SimpleEnumListMessage::LOCAL_ENUM_VALUE2,
                                                 SimpleEnumListMessage::LOCAL_ENUM_VALUE1,
                                                 SimpleEnumListMessage::LOCAL_ENUM_VALUE3});
 
     SimpleEnumListMessage test;
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<SimpleEnumListMessage::LocalEnumList>(value)));
-    ASSERT_TRUE(test.property(propertyName).value<SimpleEnumListMessage::LocalEnumList>() == value);
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<SimpleEnumListMessage::LocalEnumRepeated>(value)));
+    ASSERT_TRUE(test.property(propertyName).value<SimpleEnumListMessage::LocalEnumRepeated>() == value);
     ASSERT_TRUE(test.localEnumList() == value);
 }
 
@@ -339,16 +339,16 @@ TEST_F(SimpleTest, SimpleEnumsTest)
 TEST_F(SimpleTest, SimpleFileEnumsTest)
 {
     const char *propertyName = "globalEnumList";
-    assertMessagePropertyRegistered<SimpleFileEnumMessage, GlobalEnums::TestEnumList>(2, "qtprotobufnamespace::tests::GlobalEnums::TestEnumList", propertyName);
+    assertMessagePropertyRegistered<SimpleFileEnumMessage, GlobalEnums::TestEnumRepeated>(2, "qtprotobufnamespace::tests::GlobalEnums::TestEnumRepeated", propertyName);
 
-    GlobalEnums::TestEnumList value({GlobalEnums::TEST_ENUM_VALUE1,
+    GlobalEnums::TestEnumRepeated value({GlobalEnums::TEST_ENUM_VALUE1,
                                      GlobalEnums::TEST_ENUM_VALUE3,
                                      GlobalEnums::TEST_ENUM_VALUE4,
                                      GlobalEnums::TEST_ENUM_VALUE2,
                                      GlobalEnums::TEST_ENUM_VALUE1});
     SimpleFileEnumMessage test;
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<GlobalEnums::TestEnumList>(value)));
-    ASSERT_TRUE(test.property(propertyName).value<GlobalEnums::TestEnumList>() == value);
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<GlobalEnums::TestEnumRepeated>(value)));
+    ASSERT_TRUE(test.property(propertyName).value<GlobalEnums::TestEnumRepeated>() == value);
     ASSERT_TRUE(test.globalEnumList() == value);
 }
 
@@ -384,8 +384,8 @@ TEST_F(SimpleTest, SimpleExternalComplexMessageTest)
 TEST_F(SimpleTest, RepeatedExternalComplexMessageTest)
 {
     const char *propertyName = "testExternalComplex";
-    assertMessagePropertyRegistered<RepeatedExternalComplexMessage, qtprotobufnamespace1::externaltests::ExternalComplexMessageList>(
-                1, "qtprotobufnamespace1::externaltests::ExternalComplexMessageList", propertyName);
+    assertMessagePropertyRegistered<RepeatedExternalComplexMessage, qtprotobufnamespace1::externaltests::ExternalComplexMessageRepeated>(
+                1, "qtprotobufnamespace1::externaltests::ExternalComplexMessageRepeated", propertyName);
 
     qtprotobufnamespace1::externaltests::SimpleExternalMessage complexMessage;
     complexMessage.setLocalList({1, 2, 3, 4, 5});
@@ -393,12 +393,12 @@ TEST_F(SimpleTest, RepeatedExternalComplexMessageTest)
     QSharedPointer<qtprotobufnamespace1::externaltests::ExternalComplexMessage> externalMessage(new qtprotobufnamespace1::externaltests::ExternalComplexMessage);
     externalMessage->setTestFieldInt(complexMessage);
 
-    qtprotobufnamespace1::externaltests::ExternalComplexMessageList complexMessageList;
+    qtprotobufnamespace1::externaltests::ExternalComplexMessageRepeated complexMessageList;
     complexMessageList << externalMessage;
 
     RepeatedExternalComplexMessage test;
     ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue(complexMessageList)));
-    ASSERT_TRUE(test.property(propertyName).value<qtprotobufnamespace1::externaltests::ExternalComplexMessageList>() == complexMessageList);
+    ASSERT_TRUE(test.property(propertyName).value<qtprotobufnamespace1::externaltests::ExternalComplexMessageRepeated>() == complexMessageList);
     ASSERT_TRUE(test.testExternalComplex() == complexMessageList);
 }
 
@@ -654,15 +654,15 @@ TEST_F(SimpleTest, StepChildEnumMessageTest)
 TEST_F(SimpleTest, StepChildEnumListMessageTest)
 {
     const char *propertyName = "localStepChildList";
-    assertMessagePropertyRegistered<StepChildEnumMessage, SimpleEnumMessage::LocalEnumList>(2, "qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnumList", propertyName);
+    assertMessagePropertyRegistered<StepChildEnumMessage, SimpleEnumMessage::LocalEnumRepeated>(2, "qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnumRepeated", propertyName);
 
-    SimpleEnumMessage::LocalEnumList value({SimpleEnumMessage::LOCAL_ENUM_VALUE2,
+    SimpleEnumMessage::LocalEnumRepeated value({SimpleEnumMessage::LOCAL_ENUM_VALUE2,
                                             SimpleEnumMessage::LOCAL_ENUM_VALUE2,
                                             SimpleEnumMessage::LOCAL_ENUM_VALUE1,
                                             SimpleEnumMessage::LOCAL_ENUM_VALUE3});
     StepChildEnumMessage test;
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnumList>(value)));
-    ASSERT_TRUE(test.property(propertyName).value<SimpleEnumMessage::LocalEnumList>() == value);
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnumRepeated>(value)));
+    ASSERT_TRUE(test.property(propertyName).value<SimpleEnumMessage::LocalEnumRepeated>() == value);
     ASSERT_TRUE(test.localStepChildList() == value);
 }