Make global enums uncreatable

- Replace register for GlobalEnums them selves with enums register
TODO: Need to add explicit enum register local enums as well #96

src/generator/globalenumsgenerator.cpp

@@ -40,10 +40,11 @@ void GlobalEnumsGenerator::startEnum(const std::vector<std::string>& namespaces)
     printNamespaces(namespaces);
     printEnumClass();
     printPublic();
-    printConstructor();
     Indent();
     mPrinter.Print(Templates::ComplexTypeRegistrationMethodTemplate);
     Outdent();
+    printPrivate();
+    printConstructor();
 }
 
 void GlobalEnumsGenerator::printConstructor()

src/generator/globalenumssourcegenerator.cpp

@@ -72,16 +72,17 @@ void GlobalEnumsSourceGenerator::printRegisterBody(const std::list<const FileDes
     mPrinter.Print(registrationProperties, Templates::ComplexGlobalEnumRegistrationTemplate);
     Indent();
     Indent();
-    mPrinter.Print(registrationProperties, Templates::RegisterMetaTypeTemplate);
-    mPrinter.Print(registrationProperties, Templates::QmlRegisterTypeTemplate);
+    mPrinter.Print(registrationProperties, Templates::QmlRegisterTypeUncreatableTemplate);
 
     for (auto file : list) {
         for (int i = 0; i < file->enum_type_count(); i++) {
             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"},
                                                                    {"namespaces", fullNamespace}};
             mPrinter.Print(properties, Templates::ComplexGlobalEnumFieldRegistrationTemplate);
+            mPrinter.Print(properties, Templates::RegisterMetaTypeTemplate);
         }
     }
     Outdent();

src/generator/templates.cpp

@@ -57,7 +57,7 @@ const char *Templates::ComplexTypeRegistrationTemplate = "void $classname$::regi
                                                          "";
 const char *Templates::ComplexGlobalEnumRegistrationTemplate = "void $classname$::registerTypes()\n{\n"
                                                                "    static bool registationDone = false;\n"
-                                                               "    if (!registationDone) {\n\n"
+                                                               "    if (!registationDone) {\n"
                                                                "        registationDone = true;\n";
 const char *Templates::ComplexGlobalEnumFieldRegistrationTemplate = "qRegisterMetaType<$classname$::$enum$>(\"$namespaces$::$classname$::$enum$\");\n";
 const char *Templates::ComplexListTypeUsingTemplate = "using $classname$List = QList<QSharedPointer<$classname$>>;\n";
@@ -205,6 +205,7 @@ const char *Templates::ClientMethodDefinitionAsyncTemplate = "\nbool $classname$
 const char *Templates::SerializersTemplate = "Q_DECLARE_PROTOBUF_SERIALIZERS($classname$)\n";
 const char *Templates::RegisterSerializersTemplate = "qtprotobuf::ProtobufObjectPrivate::registerSerializers<$classname$>();\n";
 const char *Templates::QmlRegisterTypeTemplate = "qmlRegisterType<$namespaces$::$classname$>(\"$package$\", 1, 0, \"$classname$\");\n";
+const char *Templates::QmlRegisterTypeUncreatableTemplate = "qmlRegisterUncreatableType<$namespaces$::$classname$>(\"$package$\", 1, 0, \"$classname$\", \"$namespaces$::$classname$ Could not be created from qml context\");\n";
 
 const std::unordered_map<::google::protobuf::FieldDescriptor::Type, std::string> Templates::TypeReflection = {
     {::google::protobuf::FieldDescriptor::TYPE_DOUBLE, "double"},

src/generator/templates.h

@@ -110,7 +110,7 @@ public:
     static const char *SerializersTemplate;
     static const char *RegisterSerializersTemplate;
     static const char *QmlRegisterTypeTemplate;
-
+    static const char *QmlRegisterTypeUncreatableTemplate;
     //Service templates
     static const char *ConstructorDefinitionSyncTemplate;
 

tests/test_protobuf/simpletest.cpp

@@ -686,15 +686,16 @@ TEST_F(SimpleTest, RepeatedSFixedInt64MessageTest)
 TEST_F(SimpleTest, StepChildEnumMessageTest)
 {
     qtprotobufnamespace::tests::SimpleEnumMessage::registerTypes();
+
     const char* propertyName = "localStepChildEnum";
     StepChildEnumMessage test;
     int propertyNumber = StepChildEnumMessage::propertyOrdering.at(1); //See simpletest.proto
     ASSERT_STREQ(StepChildEnumMessage::staticMetaObject.property(propertyNumber).typeName(), "qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnum");
-    ASSERT_EQ(StepChildEnumMessage::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<SimpleEnumMessage::LocalEnum>());
+    ASSERT_EQ(StepChildEnumMessage::staticMetaObject.property(propertyNumber).userType(), qMetaTypeId<qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnum>());
     ASSERT_STREQ(StepChildEnumMessage::staticMetaObject.property(propertyNumber).name(), propertyName);
-    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnum>(SimpleEnumMessage::LOCAL_ENUM_VALUE2)));
-    ASSERT_TRUE(test.property(propertyName).value<SimpleEnumMessage::LocalEnum>() == SimpleEnumMessage::LOCAL_ENUM_VALUE2);
-    ASSERT_TRUE(test.localStepChildEnum() == SimpleEnumMessage::LOCAL_ENUM_VALUE2);
+    ASSERT_TRUE(test.setProperty(propertyName, QVariant::fromValue<qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnum>(qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnum::LOCAL_ENUM_VALUE2)));
+    ASSERT_TRUE(test.property(propertyName).value<qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnum>() == qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnum::LOCAL_ENUM_VALUE2);
+    ASSERT_TRUE(test.localStepChildEnum() == qtprotobufnamespace::tests::SimpleEnumMessage::LocalEnum::LOCAL_ENUM_VALUE2);
 }
 
 TEST_F(SimpleTest, StepChildEnumListMessageTest)