Add converters for basic protobuf types

- Add and register basic protobuf types converters
- Add and update tests

src/protobuf/qtprotobuf.cpp

@@ -58,6 +58,30 @@ void registerTypes() {
 
     registerProtobufType(DoubleList);
     registerProtobufType(FloatList);
+
+    QMetaType::registerConverter<int32_t, int32>(int32::fromType);
+    QMetaType::registerConverter<int32, int32_t>(int32::toType);
+
+    QMetaType::registerConverter<int64_t, int64>(int64::fromType);
+    QMetaType::registerConverter<int64, int64_t>(int64::toType);
+    QMetaType::registerConverter<qint64, int64>(int64::fromType);
+    QMetaType::registerConverter<int64, qint64>(int64::toType);
+
+    QMetaType::registerConverter<uint32_t, fixed32>(fixed32::fromType);
+    QMetaType::registerConverter<fixed32, uint32_t>(fixed32::toType);
+
+    QMetaType::registerConverter<uint64_t, fixed64>(fixed64::fromType);
+    QMetaType::registerConverter<fixed64, uint64_t>(fixed64::toType);
+    QMetaType::registerConverter<quint64, fixed64>(fixed64::fromType);
+    QMetaType::registerConverter<fixed64, quint64>(fixed64::toType);
+
+    QMetaType::registerConverter<int32_t, sfixed32>(sfixed32::fromType);
+    QMetaType::registerConverter<sfixed32, int32_t>(sfixed32::toType);
+
+    QMetaType::registerConverter<int64_t, sfixed64>(sfixed64::fromType);
+    QMetaType::registerConverter<sfixed64, int64_t>(sfixed64::toType);
+    QMetaType::registerConverter<qint64, sfixed64>(sfixed64::fromType);
+    QMetaType::registerConverter<sfixed64, qint64>(sfixed64::toType);
     ProtobufObjectPrivate::registerSerializers();
 }
 }

src/protobuf/qtprotobuftypes.h

@@ -48,6 +48,9 @@ struct transparent {
     operator T &(){ return _t; }
     operator T() const { return _t; }
     transparent &operator =(const T &t) { _t = t; return *this; }
+
+    static T toType( transparent t ) { return t._t; }
+    static transparent fromType( T _t ) { return transparent(_t); }
 };
 
 using int32 = transparent<int32_t>;

tests/test_protobuf/CMakeLists.txt

@@ -142,7 +142,8 @@ file(GLOB SOURCES
     simpletest.cpp
     serializationtest.cpp
     deserializationtest.cpp
-    serializationcomplexmessagemap.cpp)
+    serializationcomplexmessagemap.cpp
+    converterstest.cpp)
 
 add_test_target(TARGET ${TARGET}
     GENERATED_HEADERS ${GENERATED_HEADERS}

tests/test_protobuf/converterstest.cpp

@@ -0,0 +1,98 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2019 Alexey Edelev <semlanik@gmail.com>
+ *
+ * This file is part of qtprotobuf project https://git.semlanik.org/semlanik/qtprotobuf
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this
+ * software and associated documentation files (the "Software"), to deal in the Software
+ * without restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies
+ * or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+ * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <gtest/gtest.h>
+
+#include <QVariant>
+#include <qtprotobuftypes.h>
+
+namespace qtprotobuf {
+namespace tests {
+
+class CoverterTest : public ::testing::Test
+{
+public:
+    CoverterTest() = default;
+};
+
+TEST_F(CoverterTest, TestFromTypeConverters)
+{
+    QVariant testVariant;
+
+    testVariant.setValue<uint32_t>(42);
+    ASSERT_EQ(42, testVariant.value<fixed32>()._t);
+
+    testVariant.setValue<uint64_t>(43);
+    ASSERT_EQ(43, testVariant.value<fixed64>()._t);
+
+    testVariant.setValue<int32_t>(44);
+    ASSERT_EQ(44, testVariant.value<sfixed32>()._t);
+
+    testVariant.setValue<int64_t>(45);
+    ASSERT_EQ(45, testVariant.value<sfixed64>()._t);
+
+    testVariant.setValue<int32_t>(46);
+    ASSERT_EQ(46, testVariant.value<int32>()._t);
+
+    testVariant.setValue<int64_t>(47);
+    ASSERT_EQ(47, testVariant.value<int64>()._t);
+}
+
+TEST_F(CoverterTest, TestToTypeConverters)
+{
+    bool ok = false;
+    QVariant testVariant;
+    testVariant.setValue<fixed32>({42});
+    ASSERT_EQ(42, testVariant.toUInt(&ok));
+    ASSERT_TRUE(ok);
+
+    ok = false;
+    testVariant.setValue<fixed64>({43});
+    ASSERT_EQ(43, testVariant.toULongLong(&ok));
+    ASSERT_TRUE(ok);
+
+    ok = false;
+    testVariant.setValue<sfixed32>({44});
+    ASSERT_EQ(44, testVariant.toInt(&ok));
+    ASSERT_TRUE(ok);
+
+    ok = false;
+    testVariant.setValue<sfixed64>({45});
+    ASSERT_EQ(45, testVariant.toLongLong(&ok));
+    ASSERT_TRUE(ok);
+
+    ok = false;
+    testVariant.setValue<int32>({46});
+    ASSERT_EQ(46, testVariant.toInt(&ok));
+    ASSERT_TRUE(ok);
+
+    ok = false;
+    testVariant.setValue<int64>({47});
+    ASSERT_EQ(47, testVariant.toLongLong(&ok));
+    ASSERT_TRUE(ok);
+}
+
+}
+}

tests/test_protobuf/deserializationtest.cpp

@@ -90,8 +90,6 @@ using namespace qtprotobufnamespace::tests;
 using namespace qtprotobuf::tests;
 using namespace qtprotobuf;
 
-DeserializationTest::DeserializationTest() = default;
-
 TEST_F(DeserializationTest, FixedInt32MessageDeserializeTest)
 {
     SimpleFixedInt32Message test;

tests/test_protobuf/deserializationtest.h

@@ -33,7 +33,7 @@ namespace tests {
 class DeserializationTest : public ::testing::Test
 {
 public:
-    DeserializationTest();
+    DeserializationTest() = default;
 };
 
 }