qiurui
/
qtgrpc
mirror of https://github.com/qt/qtgrpc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qtgrpc/src/protobuf/qprotobufserializer.cpp

700 lines
29 KiB
C++
Raw Normal View History

Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
// Copyright (C) 2022 The Qt Company Ltd.
// Copyright (C) 2019 Alexey Edelev <semlanik@gmail.com>, Viktor Kopp <vifactor@gmail.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qprotobufserializer.h"
#include "qprotobufserializer_p.h"
Move all registration functionality to a separate unit Move functionality related to the registration of the protobuf messages to a separate header/source files. Task-number: QTBUG-120931 Change-Id: I6076b41139d43982148e46f5f315808509c4db65 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-01-20 11:44:39 +00:00
#include "qprotobufregistration.h"
Add the qtprotobufdefs_p.h The header should contain the useful for the implementation definitions and constants. This adds the ProtobufFieldNumMin and ProtobufFieldNumMax constants which reflect the minimum and maximum field numbers for the protobuf messages. Use the newly introduced constants in the places where values were duplicated. Pick-to: 6.8 Change-Id: I27c253dc4102eea04379204f72c0d6d2376fdfbb Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io> Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-06-14 12:16:47 +00:00
#include "qtprotobufdefs_p.h"
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
#include "qtprotobuftypes.h"
#include <QtCore/qmetatype.h>
#include <QtCore/qcoreapplication.h>
#include <QtCore/qmetaobject.h>
#include <QtCore/qvariant.h>
#include <QtCore/qreadwritelock.h>
Add JSON serialization and deserialization for Qt Protobuf Also, move basic API for serializers into QProtobufBaseSerializer class - add full basic types JSON serialization/deserialization functionality - add list serialization/deserialization functionality [ChangeLog][Protobuf] Edit existing QProtobufSerializer API, also move serialization/deserialization methods from QProtobufSerializer class into QProtobufBaseSerializer interface, since all of them shall be re-usable for new Json-serializer. Autotests cover: basic types and list serialization; TBD: maps, enums, Any type, OneOf, enumLists will be completed in subsequent tasks Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: I7556308062e8e576d32a371f3cb1d4f694824498 Reviewed-by: 🌴 Alexey Edelev 🌴 <alexey.edelev@qt.io>
2023-11-24 17:07:30 +00:00
#include <QtProtobuf/qprotobufmessage.h>
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
#include <QtProtobuf/private/qprotobufserializer_p.h>
Protobuf: introduce base class QProtobufMessage And inherit from it instead of QObject in messages. Messages are inherently value-types. They don't have any logic associated with them, they simply store some value(s). Value-types should be copyable and movable but QObject _is not_ because this would break connections and parenting. By making the objects Q_GADGETs we can still retain Q_PROPERTY, and by having a pointer to the object's staticMetaObject we can implement property/setProperty functionality in QProtobufMessage with minimal effort. As a side-effect of this we no longer emit, or even have, signals when values on a message changes. But, as mentioned previously, messages don't have any logic associated to them so they would never update without users either calling an associated setter function or by deserializing a new message into an already-existing object. As another side-effect: propertyCount has decreased because we no longer have QObject's 'name' property. Fixes: QTBUG-100986 Change-Id: I0366a180bf5aadd4afb075527b80cc0a3e923ab6 Reviewed-by: Alexey Edelev <alexey.edelev@qt.io>
2022-10-05 17:11:24 +00:00
#include <QtProtobuf/private/qprotobufmessage_p.h>
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
QT_BEGIN_NAMESPACE
/*!
\class QProtobufSerializer
\inmodule QtProtobuf
Update the 'since' tag in protobuf documentation Update version to 6.5, since protobuf was not released at 6.4 times. Change-Id: I1714ca467fb897e9f079cc06cdd94d26b66fe6cb Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-29 10:46:44 +00:00
\since 6.5
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
\brief The QProtobufSerializer class is interface that represents
basic functions for serialization/deserialization.
The QProtobufSerializer class registers serializers/deserializers for
Doc: Improve class summaries Linkify keywords. Properly capitalize CMake and JSON. Use canonical qt_add_protobuf instead of the versioned qt6_add_protobuf. Pick-to: 6.6 6.7 Change-Id: Ibda8ec3afd141c6903fe36610fdc6288067e6d30 Reviewed-by: Alexey Edelev <alexey.edelev@qt.io>
2023-12-28 13:02:09 +00:00
classes implementing a protobuf message, inheriting \l QProtobufMessage. These
classes are generated automatically, based on a \c{.proto} file, using the CMake
Fix links to qtprotobufgen Fix links to qtprotobufgen in QProtobufSerializer and QAbstractProtobufSerializer docs. Pick-to: 6.5 6.6 6.7 Change-Id: Ib17438308f3e5a27e4093a3c52bd3b20c6a442b5 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io>
2024-01-16 07:08:07 +00:00
function \l qt_add_protobuf or by running
\l {The qtprotobufgen Tool} {qtprotobufgen} directly.
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
*/
using namespace Qt::StringLiterals;
using namespace QtProtobufPrivate;
Change the container type of the internal type serializers The list of integrated type serializers is predefined and can be initialized statically. Using std::array allows us to avoid extra allocations and gives us clean and simple static initialization. Change-Id: I04290d3b343487d6967341502c893f76a5044139 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 11:32:06 +00:00
template<std::size_t N>
using SerializerRegistryType =
std::array<QProtobufSerializerPrivate::ProtobufSerializationHandler, N>;
namespace {
Add the pre-generated map pair property ordering The map pair require explicit "optional" flag, since all map values should be serialized independent of field presence. Use the pre-generated ordering info of the following message: message pair { optional string key = 1; optional string value = 2; } The field type is not considered when deserializing map pairs. Also remove the previous map pair ordering functions from QProtobufPropertyOrderingInfo. [ChangeLog][QtProtobuf] Removed infoForMapKey and infoForMapValue methods from the QtProtobufPrivate::QProtobufPropertyOrderingInfo structure. Pick-to: 6.7 Change-Id: I6c4411a35ac1d19b669b1acd8b56a41bf5a0dda8 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-12-17 09:59:45 +00:00
Cleanup protobuf serializer The actual protobuf serializer has multiple overheads and code duplicaiton. Serialization functions use individual ways to detect if field was initialized or not. This patch adds the general functions that detect if field was initialized or not. Also serializers previously juggled the protobuf field number to conclude the need of field header. Now the header is added under clear conditions. For STRING and BYTES lists we should use the same way of serializing/deserialing as for non-packed lists, since they are non-packed lists. Map elements should be serialized even if value is not initialized. But non-initialized keys should still be present in serialization stream. Avoid using serializeProperty when serializing the map key and use integated type serilizers directly. Pick-to: 6.5 Change-Id: I32b512acdaa9f355eea9c41f735bc9722bed0bba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-07 15:28:37 +00:00
#define QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(Type, WireType) \
{ \
QMetaType::fromType<Type>(), \
QProtobufSerializerPrivate::serializeWrapper< \
Type, QProtobufSerializerPrivate::serializeBasic<Type>>, \
QProtobufSerializerPrivate::deserializeBasic<Type>, \
QProtobufSerializerPrivate::isPresent<Type>, WireType \
}
#define QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(ListType, Type) \
{ \
QMetaType::fromType<ListType>(), \
QProtobufSerializerPrivate::serializeWrapper< \
ListType, QProtobufSerializerPrivate::serializeListType<Type>>, \
QProtobufSerializerPrivate::deserializeList<Type>, \
QProtobufSerializerPrivate::isPresent<ListType>, \
QtProtobuf::WireTypes::LengthDelimited \
}
#define QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(ListType, Type, WireType) \
{ \
QMetaType::fromType<ListType>(), \
QProtobufSerializerPrivate::serializeNonPackedWrapper< \
ListType, QProtobufSerializerPrivate::serializeNonPackedList<Type>>, \
QProtobufSerializerPrivate::deserializeNonPackedList<Type>, \
QProtobufSerializerPrivate::isPresent<ListType>, WireType \
}
Change the container type of the internal type serializers The list of integrated type serializers is predefined and can be initialized statically. Using std::array allows us to avoid extra allocations and gives us clean and simple static initialization. Change-Id: I04290d3b343487d6967341502c893f76a5044139 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 11:32:06 +00:00
constexpr SerializerRegistryType<30> IntegratedTypesSerializers = { {
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(float, QtProtobuf::WireTypes::Fixed32),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(double, QtProtobuf::WireTypes::Fixed64),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QtProtobuf::int32,
QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QtProtobuf::int64,
QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QtProtobuf::uint32,
QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QtProtobuf::uint64,
QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QtProtobuf::sint32,
QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QtProtobuf::sint64,
QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QtProtobuf::fixed32,
QtProtobuf::WireTypes::Fixed32),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QtProtobuf::fixed64,
QtProtobuf::WireTypes::Fixed64),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QtProtobuf::sfixed32,
QtProtobuf::WireTypes::Fixed32),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QtProtobuf::sfixed64,
QtProtobuf::WireTypes::Fixed64),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QtProtobuf::boolean,
QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QString,
QtProtobuf::WireTypes::LengthDelimited),
QT_CONSTRUCT_PROTOBUF_SERIALIZATION_HANDLER(QByteArray,
QtProtobuf::WireTypes::LengthDelimited),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::floatList, float),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::doubleList, double),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::int32List, QtProtobuf::int32),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::int64List, QtProtobuf::int64),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::uint32List,
QtProtobuf::uint32),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::uint64List,
QtProtobuf::uint64),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::sint32List,
QtProtobuf::sint32),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::sint64List,
QtProtobuf::sint64),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::fixed32List,
QtProtobuf::fixed32),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::fixed64List,
QtProtobuf::fixed64),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::sfixed32List,
QtProtobuf::sfixed32),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::sfixed64List,
QtProtobuf::sfixed64),
QT_CONSTRUCT_PROTOBUF_LIST_SERIALIZATION_HANDLER(QtProtobuf::boolList, QtProtobuf::boolean),
Cleanup protobuf serializer The actual protobuf serializer has multiple overheads and code duplicaiton. Serialization functions use individual ways to detect if field was initialized or not. This patch adds the general functions that detect if field was initialized or not. Also serializers previously juggled the protobuf field number to conclude the need of field header. Now the header is added under clear conditions. For STRING and BYTES lists we should use the same way of serializing/deserialing as for non-packed lists, since they are non-packed lists. Map elements should be serialized even if value is not initialized. But non-initialized keys should still be present in serialization stream. Avoid using serializeProperty when serializing the map key and use integated type serilizers directly. Pick-to: 6.5 Change-Id: I32b512acdaa9f355eea9c41f735bc9722bed0bba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-07 15:28:37 +00:00
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QStringList, QString, QtProtobuf::WireTypes::LengthDelimited),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QByteArrayList, QByteArray, QtProtobuf::WireTypes::LengthDelimited),
Change the container type of the internal type serializers The list of integrated type serializers is predefined and can be initialized statically. Using std::array allows us to avoid extra allocations and gives us clean and simple static initialization. Change-Id: I04290d3b343487d6967341502c893f76a5044139 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 11:32:06 +00:00
} };
Add the packed attribute support for the message fields Protobuf allows non-packed way of serialization of the repeated fields. This is controlled on the protobuf schema level by adding the 'packed' attribute to a message field descriptor. If the attribute is not set the default value is 'true', so all repeated messages should use the 'packed' approach when serializing. Fixes: QTBUG-103979 Change-Id: I078a18734785865a4b7b34190a642b82b7829755 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 13:59:48 +00:00
constexpr SerializerRegistryType<13> IntegratedNonPackedSerializers = { {
Cleanup protobuf serializer The actual protobuf serializer has multiple overheads and code duplicaiton. Serialization functions use individual ways to detect if field was initialized or not. This patch adds the general functions that detect if field was initialized or not. Also serializers previously juggled the protobuf field number to conclude the need of field header. Now the header is added under clear conditions. For STRING and BYTES lists we should use the same way of serializing/deserialing as for non-packed lists, since they are non-packed lists. Map elements should be serialized even if value is not initialized. But non-initialized keys should still be present in serialization stream. Avoid using serializeProperty when serializing the map key and use integated type serilizers directly. Pick-to: 6.5 Change-Id: I32b512acdaa9f355eea9c41f735bc9722bed0bba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-07 15:28:37 +00:00
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(QtProtobuf::floatList, float,
QtProtobuf::WireTypes::Fixed32),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(QtProtobuf::doubleList, double,
QtProtobuf::WireTypes::Fixed64),
Add the packed attribute support for the message fields Protobuf allows non-packed way of serialization of the repeated fields. This is controlled on the protobuf schema level by adding the 'packed' attribute to a message field descriptor. If the attribute is not set the default value is 'true', so all repeated messages should use the 'packed' approach when serializing. Fixes: QTBUG-103979 Change-Id: I078a18734785865a4b7b34190a642b82b7829755 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 13:59:48 +00:00
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QtProtobuf::int32List, QtProtobuf::int32, QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QtProtobuf::int64List, QtProtobuf::int64, QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QtProtobuf::uint32List, QtProtobuf::uint32, QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QtProtobuf::uint64List, QtProtobuf::uint64, QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QtProtobuf::sint32List, QtProtobuf::sint32, QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QtProtobuf::sint64List, QtProtobuf::sint64, QtProtobuf::WireTypes::Varint),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QtProtobuf::fixed32List, QtProtobuf::fixed32, QtProtobuf::WireTypes::Fixed32),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QtProtobuf::fixed64List, QtProtobuf::fixed64, QtProtobuf::WireTypes::Fixed64),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QtProtobuf::sfixed32List, QtProtobuf::sfixed32, QtProtobuf::WireTypes::Fixed32),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QtProtobuf::sfixed64List, QtProtobuf::sfixed64, QtProtobuf::WireTypes::Fixed64),
QT_CONSTRUCT_PROTOBUF_NON_PACKED_LIST_SERIALIZATION_HANDLER(
QtProtobuf::boolList, QtProtobuf::boolean, QtProtobuf::WireTypes::Varint),
} };
Change the container type of the internal type serializers The list of integrated type serializers is predefined and can be initialized statically. Using std::array allows us to avoid extra allocations and gives us clean and simple static initialization. Change-Id: I04290d3b343487d6967341502c893f76a5044139 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 11:32:06 +00:00
template<std::size_t N>
std::optional<QProtobufSerializerPrivate::ProtobufSerializationHandler>
findIntegratedTypeHandlerImpl(QMetaType metaType, const SerializerRegistryType<N> &registry)
{
typename SerializerRegistryType<N>::const_iterator it = std::find_if(
registry.begin(), registry.end(),
[&metaType](const QProtobufSerializerPrivate::ProtobufSerializationHandler &handler) {
return handler.metaType == metaType;
});
if (it == registry.end())
return std::nullopt;
return { *it };
}
std::optional<QProtobufSerializerPrivate::ProtobufSerializationHandler>
Add the packed attribute support for the message fields Protobuf allows non-packed way of serialization of the repeated fields. This is controlled on the protobuf schema level by adding the 'packed' attribute to a message field descriptor. If the attribute is not set the default value is 'true', so all repeated messages should use the 'packed' approach when serializing. Fixes: QTBUG-103979 Change-Id: I078a18734785865a4b7b34190a642b82b7829755 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 13:59:48 +00:00
findIntegratedTypeHandler(QMetaType metaType, bool nonPacked)
Change the container type of the internal type serializers The list of integrated type serializers is predefined and can be initialized statically. Using std::array allows us to avoid extra allocations and gives us clean and simple static initialization. Change-Id: I04290d3b343487d6967341502c893f76a5044139 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 11:32:06 +00:00
{
Add the packed attribute support for the message fields Protobuf allows non-packed way of serialization of the repeated fields. This is controlled on the protobuf schema level by adding the 'packed' attribute to a message field descriptor. If the attribute is not set the default value is 'true', so all repeated messages should use the 'packed' approach when serializing. Fixes: QTBUG-103979 Change-Id: I078a18734785865a4b7b34190a642b82b7829755 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 13:59:48 +00:00
if (nonPacked)
return findIntegratedTypeHandlerImpl(metaType, IntegratedNonPackedSerializers);
Change the container type of the internal type serializers The list of integrated type serializers is predefined and can be initialized statically. Using std::array allows us to avoid extra allocations and gives us clean and simple static initialization. Change-Id: I04290d3b343487d6967341502c893f76a5044139 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 11:32:06 +00:00
return findIntegratedTypeHandlerImpl(metaType, IntegratedTypesSerializers);
}
}
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
/*!
Constructs a new serializer instance.
*/
QProtobufSerializer::QProtobufSerializer() : d_ptr(new QProtobufSerializerPrivate(this))
{
}
/*!
Destroys the serializer instance.
*/
QProtobufSerializer::~QProtobufSerializer() = default;
Remove the redundant property ordering forwarding from all interfaces QProtobufMessage::propertyOrdering now allows accessing the message property ordering. So we can remove extra arguments from all interfaces where the pointer or the reference to the related QProtobufMessage is used as argument too. [ChangeLog][Protobuf][QAbstractProtobufSerializer] The following interfaces do not accept the QProtobufPropertyOrdering as an argument anymore: - serializeObject - deserializeObject - serializeListObject - deserializeListObject - serializeMessage - deserializeMessage Task-number: QTBUG-120931 Change-Id: I55cb8d3ceddd56751d542869e26aa0de73c22ebb Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-01-26 13:05:04 +00:00
QByteArray QProtobufSerializer::serializeMessage(const QProtobufMessage *message) const
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
Add the missing clearError calls We should clear the previously set error when start deserializing messages. Amends e3abfef0cda5a00b73df1ba067f805fd38b6fb97 Pick-to: 6.7 Change-Id: I5e58af831217539ab75b48558e696fb4f661b7c8 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-17 10:45:47 +00:00
d_ptr->clearError();
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
d_ptr->result = {};
Remove the redundant property ordering forwarding from all interfaces QProtobufMessage::propertyOrdering now allows accessing the message property ordering. So we can remove extra arguments from all interfaces where the pointer or the reference to the related QProtobufMessage is used as argument too. [ChangeLog][Protobuf][QAbstractProtobufSerializer] The following interfaces do not accept the QProtobufPropertyOrdering as an argument anymore: - serializeObject - deserializeObject - serializeListObject - deserializeListObject - serializeMessage - deserializeMessage Task-number: QTBUG-120931 Change-Id: I55cb8d3ceddd56751d542869e26aa0de73c22ebb Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-01-26 13:05:04 +00:00
d_ptr->serializeMessage(message);
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
return d_ptr->result;
}
Remove the redundant property ordering forwarding from all interfaces QProtobufMessage::propertyOrdering now allows accessing the message property ordering. So we can remove extra arguments from all interfaces where the pointer or the reference to the related QProtobufMessage is used as argument too. [ChangeLog][Protobuf][QAbstractProtobufSerializer] The following interfaces do not accept the QProtobufPropertyOrdering as an argument anymore: - serializeObject - deserializeObject - serializeListObject - deserializeListObject - serializeMessage - deserializeMessage Task-number: QTBUG-120931 Change-Id: I55cb8d3ceddd56751d542869e26aa0de73c22ebb Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-01-26 13:05:04 +00:00
void QProtobufSerializerPrivate::serializeMessage(const QProtobufMessage *message)
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
{
Remove the redundant property ordering forwarding from all interfaces QProtobufMessage::propertyOrdering now allows accessing the message property ordering. So we can remove extra arguments from all interfaces where the pointer or the reference to the related QProtobufMessage is used as argument too. [ChangeLog][Protobuf][QAbstractProtobufSerializer] The following interfaces do not accept the QProtobufPropertyOrdering as an argument anymore: - serializeObject - deserializeObject - serializeListObject - deserializeListObject - serializeMessage - deserializeMessage Task-number: QTBUG-120931 Change-Id: I55cb8d3ceddd56751d542869e26aa0de73c22ebb Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-01-26 13:05:04 +00:00
Q_ASSERT(message != nullptr);
auto ordering = message->propertyOrdering();
Q_ASSERT(ordering != nullptr);
for (int index = 0; index < ordering->fieldCount(); ++index) {
Remove 'get' prefixes of QProtobufPropertyOrdering methods Follow the Qt style in getter naming. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: I8518ee5095fbab88864013c95de23f287ea58c5a Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-05 11:39:15 +00:00
int fieldIndex = ordering->fieldNumber(index);
Add the qtprotobufdefs_p.h The header should contain the useful for the implementation definitions and constants. This adds the ProtobufFieldNumMin and ProtobufFieldNumMax constants which reflect the minimum and maximum field numbers for the protobuf messages. Use the newly introduced constants in the places where values were duplicated. Pick-to: 6.8 Change-Id: I27c253dc4102eea04379204f72c0d6d2376fdfbb Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io> Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-06-14 12:16:47 +00:00
Q_ASSERT_X(fieldIndex <= ProtobufFieldNumMax && fieldIndex >= ProtobufFieldNumMin, "",
"fieldIndex is out of range");
Rename QProtobufPropertyOrderingInfo to QProtobufFieldInfo The struct represents the protobuf field information, so rename it accordingly. Task-number: QTBUG-123626 Change-Id: I79605a349f35e73c9fc808c76073d5c1c83c9731 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-18 12:34:47 +00:00
QProtobufFieldInfo fieldInfo(*ordering, index);
Add support for the 'oneof' type This patch adds support for 'oneof', a union-like type in protobuf, that need not contain a value, with the following features: - Setting a oneof field will automatically clear all other members of the oneof. - If the parser encounters multiple members of the same oneof on the wire, only the last member seen is used in the parsed message. - A oneof cannot be repeated. - A oneof cannot contain repeated or map fields. - If you set a oneof field to the default value (even the default, such as 0 for an int32 oneof field), the "case" of that oneof field will be set, and the value will be serialized on the wire. Unlike the reference C++ implementation, the Qt implementation of 'oneof' fields adds the 'has<PropertyName>' functions for every 'oneof' member. The protobuf generator generates a Q_PROPERTY for each member of the 'oneof'; these properties are collectively implemented as a single class member. 'oneof' fields are represented by the QtProtobufPrivate::QProtobufOptional class. The class holds the 'oneof' field number and the value that it contains as QVariant. A QExplicitSharedDataPointer is used as reference counter, and to copy and to free the memory of protobuf messages that are stored inside the nested QVariant as pointers. The class could also be used to hold 'optional' fields in follow up commits, but has small overhead since it holds field number, that is not used by optional fields. The generated classes also allows reading field number that is currently stored in the 'oneof' field. The QtProtobuf::InvalidFieldNumber constant indicates that oneof fields is uninitialized. The serialization and deserialization tests use the expected values from the results of the reference C++ serialization(protobuf version 3.19). Task-number: QTBUG-103981 Change-Id: Ie4053cb164bba6bc5f14f8cedb34bad62a638c43 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-12-27 14:23:14 +00:00
QVariant propertyValue = message->property(fieldInfo);
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
serializeProperty(propertyValue, fieldInfo);
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
if (preserveUnknownFields) {
Allow skipping unknown fields when deserializing protobuf messages Add the QProtobufSerializer::shouldPreserveUnknownFields function. The function controls whether the unknown fields received from the wire should be stored in the resulting message or should be omitted. Change-Id: I898e67ff4b162bd0e56970a704f7359adeb653e1 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-11-18 12:59:43 +00:00
// Restore any unknown fields we have stored away:
const QProtobufMessagePrivate *messagePrivate = QProtobufMessagePrivate::get(message);
for (const auto &fields : messagePrivate->unknownEntries)
result += fields.join();
}
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
void QProtobufSerializerPrivate::setUnexpectedEndOfStreamError()
{
setDeserializationError(QAbstractProtobufSerializer::UnexpectedEndOfStreamError,
Fix all translate strings It was supposed to be 'translate', not 'tr'. Change-Id: I315285ccc9df1772fdaba8bcd1db658171796140 Reviewed-by: Alexey Edelev <alexey.edelev@qt.io>
2022-12-01 15:12:21 +00:00
QCoreApplication::translate("QtProtobuf", "Unexpected end of stream"));
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
void QProtobufSerializerPrivate::clearError()
{
deserializationError = QAbstractProtobufSerializer::NoError;
deserializationErrorString.clear();
}
Remove the redundant property ordering forwarding from all interfaces QProtobufMessage::propertyOrdering now allows accessing the message property ordering. So we can remove extra arguments from all interfaces where the pointer or the reference to the related QProtobufMessage is used as argument too. [ChangeLog][Protobuf][QAbstractProtobufSerializer] The following interfaces do not accept the QProtobufPropertyOrdering as an argument anymore: - serializeObject - deserializeObject - serializeListObject - deserializeListObject - serializeMessage - deserializeMessage Task-number: QTBUG-120931 Change-Id: I55cb8d3ceddd56751d542869e26aa0de73c22ebb Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-01-26 13:05:04 +00:00
bool QProtobufSerializer::deserializeMessage(QProtobufMessage *message, QByteArrayView data) const
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
d_ptr->cachedPropertyValue = QVariant();
d_ptr->cachedIndex = -1;
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
d_ptr->clearError();
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
d_ptr->it = QProtobufSelfcheckIterator::fromView(data);
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
bool ok = true;
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
while (d_ptr->it.isValid() && d_ptr->it != data.end()) {
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
if (!d_ptr->deserializeProperty(message)) {
ok = false;
break;
}
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
if (!d_ptr->storeCachedValue(message) || !ok)
return false;
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
if (!d_ptr->it.isValid())
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
d_ptr->setUnexpectedEndOfStreamError();
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
return d_ptr->it.isValid();
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
void QProtobufSerializerPrivate::serializeObject(const QProtobufMessage *message,
Rename QProtobufPropertyOrderingInfo to QProtobufFieldInfo The struct represents the protobuf field information, so rename it accordingly. Task-number: QTBUG-123626 Change-Id: I79605a349f35e73c9fc808c76073d5c1c83c9731 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-18 12:34:47 +00:00
const QProtobufFieldInfo &fieldInfo)
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
{
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
auto store = result;
result = {};
serializeMessage(message);
Remove 'get' prefixes of QProtobufPropertyOrdering methods Follow the Qt style in getter naming. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: I8518ee5095fbab88864013c95de23f287ea58c5a Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-05 11:39:15 +00:00
store.append(QProtobufSerializerPrivate::encodeHeader(fieldInfo.fieldNumber(),
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
QtProtobuf::WireTypes::LengthDelimited));
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
store.append(QProtobufSerializerPrivate::serializeVarintCommon<uint32_t>(result.size()));
store.append(result);
result = store;
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
bool QProtobufSerializerPrivate::deserializeObject(QProtobufMessage *message)
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
if (it.bytesLeft() == 0) {
setUnexpectedEndOfStreamError();
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
return false;
}
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
std::optional<QByteArray>
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
array = QProtobufSerializerPrivate::deserializeLengthDelimited(it);
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
if (!array) {
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
setUnexpectedEndOfStreamError();
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
return false;
}
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
auto restoreOnReturn = qScopeGuard([prevIt = it, prevCachedPropertyValue = cachedPropertyValue,
prevCachedIndex = cachedIndex, this]() {
it = prevIt;
cachedPropertyValue = prevCachedPropertyValue;
cachedIndex = prevCachedIndex;
});
cachedPropertyValue.clear();
cachedIndex = -1;
Fix restoring previous iterator in deserializeObject We were previously just restoring the iterator in one branch. This made it really hard to debug unrelated issues that happened to leave through another branch. This changes what iterator we are checking for validity before leaving the function, but the iterator shouldn't have consumed more data than is available in the buffer, so it should be valid anyway. Pick-to: 6.8 6.7 Change-Id: Iaa818a54961feacb50a20a1f9770a05308cb2485 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io>
2024-05-29 22:09:35 +00:00
QByteArrayView data = *array;
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
clearError();
it = QProtobufSelfcheckIterator::fromView(data);
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
bool ok = true;
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
while (it.isValid() && it != data.end()) {
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
if (!deserializeProperty(message)) {
ok = false;
break;
}
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
}
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
if (!storeCachedValue(message) || !ok)
return false;
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
if (!it.isValid())
setUnexpectedEndOfStreamError();
return it.isValid();
}
void QProtobufSerializer::serializeObject(const QProtobufMessage *message,
Rename QProtobufPropertyOrderingInfo to QProtobufFieldInfo The struct represents the protobuf field information, so rename it accordingly. Task-number: QTBUG-123626 Change-Id: I79605a349f35e73c9fc808c76073d5c1c83c9731 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-18 12:34:47 +00:00
const QProtobufFieldInfo &fieldInfo) const
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
{
d_ptr->serializeObject(message, fieldInfo);
}
bool QProtobufSerializer::deserializeObject(QProtobufMessage *message) const
{
return d_ptr->deserializeObject(message);
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
void QProtobufSerializerPrivate::serializeEnumList(const QList<QtProtobuf::int64> &value,
const QProtobufFieldInfo &fieldInfo)
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
if (value.isEmpty())
return;
Cleanup protobuf serializer The actual protobuf serializer has multiple overheads and code duplicaiton. Serialization functions use individual ways to detect if field was initialized or not. This patch adds the general functions that detect if field was initialized or not. Also serializers previously juggled the protobuf field number to conclude the need of field header. Now the header is added under clear conditions. For STRING and BYTES lists we should use the same way of serializing/deserialing as for non-packed lists, since they are non-packed lists. Map elements should be serialized even if value is not initialized. But non-initialized keys should still be present in serialization stream. Avoid using serializeProperty when serializing the map key and use integated type serilizers directly. Pick-to: 6.5 Change-Id: I32b512acdaa9f355eea9c41f735bc9722bed0bba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-07 15:28:37 +00:00
Remove 'get' prefixes of QProtobufPropertyOrdering methods Follow the Qt style in getter naming. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: I8518ee5095fbab88864013c95de23f287ea58c5a Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-05 11:39:15 +00:00
auto header = QProtobufSerializerPrivate::encodeHeader(fieldInfo.fieldNumber(),
Cleanup protobuf serializer The actual protobuf serializer has multiple overheads and code duplicaiton. Serialization functions use individual ways to detect if field was initialized or not. This patch adds the general functions that detect if field was initialized or not. Also serializers previously juggled the protobuf field number to conclude the need of field header. Now the header is added under clear conditions. For STRING and BYTES lists we should use the same way of serializing/deserialing as for non-packed lists, since they are non-packed lists. Map elements should be serialized even if value is not initialized. But non-initialized keys should still be present in serialization stream. Avoid using serializeProperty when serializing the map key and use integated type serilizers directly. Pick-to: 6.5 Change-Id: I32b512acdaa9f355eea9c41f735bc9722bed0bba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-07 15:28:37 +00:00
QtProtobuf::WireTypes::LengthDelimited);
Scope the QtProtobufPrivate::FieldFlag enum Covert the QtProtobufPrivate::FieldFlag enum to a enum class. This will ensure that enum values will not conflict in the future. Task-number: QTBUG-123626 Pick-to: 6.8 Change-Id: Ibd4d68ac4b27087e5e9e35ba6e4e28242b2cd893 Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-08 21:06:43 +00:00
if (fieldInfo.fieldFlags().testFlag(QtProtobufPrivate::FieldFlag::NonPacked))
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
result
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
.append(QProtobufSerializerPrivate::serializeNonPackedList<QtProtobuf::int64>(value,
header));
else
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
result.append(header
+ QProtobufSerializerPrivate::serializeListType<QtProtobuf::int64>(value));
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
bool QProtobufSerializerPrivate::deserializeEnumList(QList<QtProtobuf::int64> &value)
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
QVariant variantValue;
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
if (!QProtobufSerializerPrivate::deserializeList<QtProtobuf::int64>(it, variantValue)) {
setUnexpectedEndOfStreamError();
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
return false;
}
value = variantValue.value<QList<QtProtobuf::int64>>();
return true;
}
QProtobufSerializerPrivate::QProtobufSerializerPrivate(QProtobufSerializer *q) : q_ptr(q)
{
}
Move encodeHeader and decodeHeader functions to .cpp file Make the functions non-inline and move to .cpp file. Pick-to: 6.5 6.6 Task-number: QTBUG-116415 Change-Id: I26efb11c23cbf3ee4210cd10b7d3a4cb67219104 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io> Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io>
2023-08-26 10:31:13 +00:00
/*!
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
\internal
Move encodeHeader and decodeHeader functions to .cpp file Make the functions non-inline and move to .cpp file. Pick-to: 6.5 6.6 Task-number: QTBUG-116415 Change-Id: I26efb11c23cbf3ee4210cd10b7d3a4cb67219104 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io> Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io>
2023-08-26 10:31:13 +00:00
Encode a property field index and its type into output bytes.
Header byte
Meaning | Field index | Type
---------- | ------------- | --------
bit number | 7 6 5 4 3 | 2 1 0
fieldIndex: The index of a property in parent object
wireType: Serialization type used for the property with index @p fieldIndex
Returns a varint-encoded fieldIndex and wireType
*/
QByteArray QProtobufSerializerPrivate::encodeHeader(int fieldIndex,
QtProtobuf::WireTypes wireType)
{
uint32_t header = (fieldIndex << 3) | int(wireType);
return serializeVarintCommon<uint32_t>(header);
}
/*!
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
\internal
Move encodeHeader and decodeHeader functions to .cpp file Make the functions non-inline and move to .cpp file. Pick-to: 6.5 6.6 Task-number: QTBUG-116415 Change-Id: I26efb11c23cbf3ee4210cd10b7d3a4cb67219104 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io> Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io>
2023-08-26 10:31:13 +00:00
Decode a property field index and its serialization type from input bytes
Iterator: that points to header with encoded field index and serialization type
fieldIndex: Decoded index of a property in parent object
wireType: Decoded serialization type used for the property with index
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
Return true if both decoded wireType and fieldIndex have "allowed" values and false, otherwise
Move encodeHeader and decodeHeader functions to .cpp file Make the functions non-inline and move to .cpp file. Pick-to: 6.5 6.6 Task-number: QTBUG-116415 Change-Id: I26efb11c23cbf3ee4210cd10b7d3a4cb67219104 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io> Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io>
2023-08-26 10:31:13 +00:00
*/
bool QProtobufSerializerPrivate::decodeHeader(QProtobufSelfcheckIterator &it,
int &fieldIndex,
QtProtobuf::WireTypes &wireType)
{
if (it.bytesLeft() == 0)
return false;
auto opt = deserializeVarintCommon<uint32_t>(it);
if (!opt)
return false;
uint32_t header = opt.value();
wireType = static_cast<QtProtobuf::WireTypes>(header & 0b00000111);
fieldIndex = header >> 3;
constexpr int maxFieldIndex = (1 << 29) - 1;
return fieldIndex <= maxFieldIndex && fieldIndex > 0
&& (wireType == QtProtobuf::WireTypes::Varint
|| wireType == QtProtobuf::WireTypes::Fixed64
|| wireType == QtProtobuf::WireTypes::Fixed32
|| wireType == QtProtobuf::WireTypes::LengthDelimited);
}
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
void QProtobufSerializerPrivate::skipVarint(QProtobufSelfcheckIterator &it)
{
while ((*it) & 0x80)
++it;
++it;
}
void QProtobufSerializerPrivate::skipLengthDelimited(QProtobufSelfcheckIterator &it)
{
//Get length of length-delimited field
auto opt = QProtobufSerializerPrivate::deserializeVarintCommon<QtProtobuf::uint64>(it);
if (!opt) {
Force invalidating unknown length-delimited field If we were unable to read the unknown length-delimited field size we need to invalidate the further deserializing procedure, since the buffer is malformed. Pick-to: 6.5 6.5.0 Change-Id: I6bbc3ed99b8390435aefbee15eefa3dc6a3a2ce9 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-04 18:42:16 +00:00
it += it.bytesLeft() + 1;
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
return;
}
QtProtobuf::uint64 length = opt.value();
it += length;
}
qsizetype QProtobufSerializerPrivate::skipSerializedFieldBytes(QProtobufSelfcheckIterator &it, QtProtobuf::WireTypes type)
{
const auto *initialIt = QByteArray::const_iterator(it);
switch (type) {
case QtProtobuf::WireTypes::Varint:
skipVarint(it);
break;
case QtProtobuf::WireTypes::Fixed32:
Rename the TransparentWrapper::_t member to t C++ advices not to use the underscore prefixed identifiers. Rename TransparentWrapper::_t accordingly. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Iaee3260f7c253a631dab014e3ec523f8b02b49f9 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-08 10:20:52 +00:00
it += sizeof(decltype(QtProtobuf::fixed32::t));
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
break;
case QtProtobuf::WireTypes::Fixed64:
Rename the TransparentWrapper::_t member to t C++ advices not to use the underscore prefixed identifiers. Rename TransparentWrapper::_t accordingly. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Iaee3260f7c253a631dab014e3ec523f8b02b49f9 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-08 10:20:52 +00:00
it += sizeof(decltype(QtProtobuf::fixed64::t));
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
break;
case QtProtobuf::WireTypes::LengthDelimited:
skipLengthDelimited(it);
break;
case QtProtobuf::WireTypes::Unknown:
default:
Q_UNREACHABLE();
return 0;
}
return std::distance(initialIt, QByteArray::const_iterator(it));
}
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
void QProtobufSerializerPrivate::serializeProperty(const QVariant &propertyValue,
Rename QProtobufPropertyOrderingInfo to QProtobufFieldInfo The struct represents the protobuf field information, so rename it accordingly. Task-number: QTBUG-123626 Change-Id: I79605a349f35e73c9fc808c76073d5c1c83c9731 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-18 12:34:47 +00:00
const QProtobufFieldInfo &fieldInfo)
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
QMetaType metaType = propertyValue.metaType();
Remove 'get' prefixes of QProtobufPropertyOrdering methods Follow the Qt style in getter naming. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: I8518ee5095fbab88864013c95de23f287ea58c5a Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-05 11:39:15 +00:00
qProtoDebug() << "propertyValue" << propertyValue << "fieldIndex" << fieldInfo.fieldNumber()
Add support for the 'oneof' type This patch adds support for 'oneof', a union-like type in protobuf, that need not contain a value, with the following features: - Setting a oneof field will automatically clear all other members of the oneof. - If the parser encounters multiple members of the same oneof on the wire, only the last member seen is used in the parsed message. - A oneof cannot be repeated. - A oneof cannot contain repeated or map fields. - If you set a oneof field to the default value (even the default, such as 0 for an int32 oneof field), the "case" of that oneof field will be set, and the value will be serialized on the wire. Unlike the reference C++ implementation, the Qt implementation of 'oneof' fields adds the 'has<PropertyName>' functions for every 'oneof' member. The protobuf generator generates a Q_PROPERTY for each member of the 'oneof'; these properties are collectively implemented as a single class member. 'oneof' fields are represented by the QtProtobufPrivate::QProtobufOptional class. The class holds the 'oneof' field number and the value that it contains as QVariant. A QExplicitSharedDataPointer is used as reference counter, and to copy and to free the memory of protobuf messages that are stored inside the nested QVariant as pointers. The class could also be used to hold 'optional' fields in follow up commits, but has small overhead since it holds field number, that is not used by optional fields. The generated classes also allows reading field number that is currently stored in the 'oneof' field. The QtProtobuf::InvalidFieldNumber constant indicates that oneof fields is uninitialized. The serialization and deserialization tests use the expected values from the results of the reference C++ serialization(protobuf version 3.19). Task-number: QTBUG-103981 Change-Id: Ie4053cb164bba6bc5f14f8cedb34bad62a638c43 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-12-27 14:23:14 +00:00
<< "metaType" << metaType.name();
if (metaType.id() == QMetaType::UnknownType || propertyValue.isNull()) {
// Empty value
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
return;
Add support for the 'oneof' type This patch adds support for 'oneof', a union-like type in protobuf, that need not contain a value, with the following features: - Setting a oneof field will automatically clear all other members of the oneof. - If the parser encounters multiple members of the same oneof on the wire, only the last member seen is used in the parsed message. - A oneof cannot be repeated. - A oneof cannot contain repeated or map fields. - If you set a oneof field to the default value (even the default, such as 0 for an int32 oneof field), the "case" of that oneof field will be set, and the value will be serialized on the wire. Unlike the reference C++ implementation, the Qt implementation of 'oneof' fields adds the 'has<PropertyName>' functions for every 'oneof' member. The protobuf generator generates a Q_PROPERTY for each member of the 'oneof'; these properties are collectively implemented as a single class member. 'oneof' fields are represented by the QtProtobufPrivate::QProtobufOptional class. The class holds the 'oneof' field number and the value that it contains as QVariant. A QExplicitSharedDataPointer is used as reference counter, and to copy and to free the memory of protobuf messages that are stored inside the nested QVariant as pointers. The class could also be used to hold 'optional' fields in follow up commits, but has small overhead since it holds field number, that is not used by optional fields. The generated classes also allows reading field number that is currently stored in the 'oneof' field. The QtProtobuf::InvalidFieldNumber constant indicates that oneof fields is uninitialized. The serialization and deserialization tests use the expected values from the results of the reference C++ serialization(protobuf version 3.19). Task-number: QTBUG-103981 Change-Id: Ie4053cb164bba6bc5f14f8cedb34bad62a638c43 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-12-27 14:23:14 +00:00
}
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
if (metaType.flags() & QMetaType::IsPointer) {
auto *messageProperty = propertyValue.value<QProtobufMessage *>();
auto store = result;
result = {};
serializeMessage(messageProperty);
store.append(QProtobufSerializerPrivate::
Remove 'get' prefixes of QProtobufPropertyOrdering methods Follow the Qt style in getter naming. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: I8518ee5095fbab88864013c95de23f287ea58c5a Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-05 11:39:15 +00:00
encodeHeader(fieldInfo.fieldNumber(),
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
QtProtobuf::WireTypes::LengthDelimited));
store.append(QProtobufSerializerPrivate::serializeVarintCommon<uint32_t>(result.size()));
store.append(result);
result = store;
Add the missing 'return' to QProtobufSerializerPrivate::serializeProperty If we are confident that the property is message, we shouldn't attempt to look for other serializers. Pick-to: 6.7 Change-Id: I61c76d9dc2c43d5b8a91627d1e3a7aaebbb8d166 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-05-20 12:00:59 +00:00
return;
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
}
Remove 'get' prefixes of QProtobufPropertyOrdering methods Follow the Qt style in getter naming. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: I8518ee5095fbab88864013c95de23f287ea58c5a Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-05 11:39:15 +00:00
const auto fieldFlags = fieldInfo.fieldFlags();
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
if (fieldFlags.testFlag(QtProtobufPrivate::FieldFlag::Enum)) {
if (fieldFlags.testFlag(QtProtobufPrivate::FieldFlag::Repeated)) {
auto value = propertyValue.value<QList<QtProtobuf::int64>>();
serializeEnumList(value, fieldInfo);
} else {
auto value = propertyValue.value<int64_t>();
if (value == 0 && !isOneofOrOptionalField(fieldInfo))
return;
Remove 'get' prefixes of QProtobufPropertyOrdering methods Follow the Qt style in getter naming. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: I8518ee5095fbab88864013c95de23f287ea58c5a Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-05 11:39:15 +00:00
result.append(QProtobufSerializerPrivate::encodeHeader(fieldInfo.fieldNumber(),
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
QtProtobuf::WireTypes::Varint));
result.append(QProtobufSerializerPrivate::serializeBasic<
QtProtobuf::int64>(propertyValue.value<int64_t>()));
}
Remove QAbstractProtobufSerializer::(de)serializeEnum interface Move the enum detection into the serilaizer implementations. Task-number: QTBUG-123626 Change-Id: I45e5d7b058b08a7489f0f61c5c66ffdbeae8a4ba Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-04-27 10:23:41 +00:00
return;
}
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
auto basicHandler = findIntegratedTypeHandler(metaType,
fieldFlags
Scope the QtProtobufPrivate::FieldFlag enum Covert the QtProtobufPrivate::FieldFlag enum to a enum class. This will ensure that enum values will not conflict in the future. Task-number: QTBUG-123626 Pick-to: 6.8 Change-Id: Ibd4d68ac4b27087e5e9e35ba6e4e28242b2cd893 Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-08 21:06:43 +00:00
.testFlag(QtProtobufPrivate::FieldFlag::NonPacked));
Change the container type of the internal type serializers The list of integrated type serializers is predefined and can be initialized statically. Using std::array allows us to avoid extra allocations and gives us clean and simple static initialization. Change-Id: I04290d3b343487d6967341502c893f76a5044139 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 11:32:06 +00:00
if (basicHandler) {
Implement support of 'optional' fields 'optional' fields is the legacy mechanism from 'proto2' times. In 'proto3' schemes this keyword changes the 'presence' handling of the fields that are marked as 'optional'. By default protobuf messages(serializer to be precise) treat all fields as optional. This means that if field has the default value(0, 0.0f, false, nullptr) the field will not be serialized at all. This mechanism can be overwritten using the 'optional' attribute or keyword. If the message field is marked as 'optional' it gets the following methods in addition to the regular field one: - clear<fieldName> - has<fieldName> These methods allow to clear the value and to check whether the field was ever set. The optional fields get serialized if they were explicitly set in the message, even if they have the default value. This is the key difference that this attribute/keyword makes on the serialization process. [ChangeLog][QtProtobuf] All message fieds now have 'has' methods that indicate if message was initialized and contain value or not. Task-number: QTBUG-103978 Change-Id: Ia948be85486175bb2d81357352f5c04da12af846 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io>
2023-08-27 13:33:59 +00:00
bool serializeUninitialized = isOneofOrOptionalField(fieldInfo);
Cleanup protobuf serializer The actual protobuf serializer has multiple overheads and code duplicaiton. Serialization functions use individual ways to detect if field was initialized or not. This patch adds the general functions that detect if field was initialized or not. Also serializers previously juggled the protobuf field number to conclude the need of field header. Now the header is added under clear conditions. For STRING and BYTES lists we should use the same way of serializing/deserialing as for non-packed lists, since they are non-packed lists. Map elements should be serialized even if value is not initialized. But non-initialized keys should still be present in serialization stream. Avoid using serializeProperty when serializing the map key and use integated type serilizers directly. Pick-to: 6.5 Change-Id: I32b512acdaa9f355eea9c41f735bc9722bed0bba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-07 15:28:37 +00:00
if (!basicHandler->isPresent(propertyValue) && !serializeUninitialized) {
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
return;
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
Cleanup protobuf serializer The actual protobuf serializer has multiple overheads and code duplicaiton. Serialization functions use individual ways to detect if field was initialized or not. This patch adds the general functions that detect if field was initialized or not. Also serializers previously juggled the protobuf field number to conclude the need of field header. Now the header is added under clear conditions. For STRING and BYTES lists we should use the same way of serializing/deserialing as for non-packed lists, since they are non-packed lists. Map elements should be serialized even if value is not initialized. But non-initialized keys should still be present in serialization stream. Avoid using serializeProperty when serializing the map key and use integated type serilizers directly. Pick-to: 6.5 Change-Id: I32b512acdaa9f355eea9c41f735bc9722bed0bba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-07 15:28:37 +00:00
Remove 'get' prefixes of QProtobufPropertyOrdering methods Follow the Qt style in getter naming. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: I8518ee5095fbab88864013c95de23f287ea58c5a Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-05 11:39:15 +00:00
QByteArray header = QProtobufSerializerPrivate::encodeHeader(fieldInfo.fieldNumber(),
Cleanup protobuf serializer The actual protobuf serializer has multiple overheads and code duplicaiton. Serialization functions use individual ways to detect if field was initialized or not. This patch adds the general functions that detect if field was initialized or not. Also serializers previously juggled the protobuf field number to conclude the need of field header. Now the header is added under clear conditions. For STRING and BYTES lists we should use the same way of serializing/deserialing as for non-packed lists, since they are non-packed lists. Map elements should be serialized even if value is not initialized. But non-initialized keys should still be present in serialization stream. Avoid using serializeProperty when serializing the map key and use integated type serilizers directly. Pick-to: 6.5 Change-Id: I32b512acdaa9f355eea9c41f735bc9722bed0bba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-07 15:28:37 +00:00
basicHandler->wireType);
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
result.append(basicHandler->serializer(propertyValue, header));
return;
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
Cleanup protobuf serializer The actual protobuf serializer has multiple overheads and code duplicaiton. Serialization functions use individual ways to detect if field was initialized or not. This patch adds the general functions that detect if field was initialized or not. Also serializers previously juggled the protobuf field number to conclude the need of field header. Now the header is added under clear conditions. For STRING and BYTES lists we should use the same way of serializing/deserialing as for non-packed lists, since they are non-packed lists. Map elements should be serialized even if value is not initialized. But non-initialized keys should still be present in serialization stream. Avoid using serializeProperty when serializing the map key and use integated type serilizers directly. Pick-to: 6.5 Change-Id: I32b512acdaa9f355eea9c41f735bc9722bed0bba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-07 15:28:37 +00:00
auto handler = QtProtobufPrivate::findHandler(metaType);
if (!handler.serializer) {
qProtoWarning() << "No serializer for type" << propertyValue.typeName();
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
return;
Cleanup protobuf serializer The actual protobuf serializer has multiple overheads and code duplicaiton. Serialization functions use individual ways to detect if field was initialized or not. This patch adds the general functions that detect if field was initialized or not. Also serializers previously juggled the protobuf field number to conclude the need of field header. Now the header is added under clear conditions. For STRING and BYTES lists we should use the same way of serializing/deserialing as for non-packed lists, since they are non-packed lists. Map elements should be serialized even if value is not initialized. But non-initialized keys should still be present in serialization stream. Avoid using serializeProperty when serializing the map key and use integated type serilizers directly. Pick-to: 6.5 Change-Id: I32b512acdaa9f355eea9c41f735bc9722bed0bba Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-07 15:28:37 +00:00
}
Make QProtobufSerializer and QProtobufJsonSerializer non-stateless QtProtobuf serializers now hold states that makes them mutable during the serializing process. QProtobufSerializer now iterate over the data received from wire implicitly, without exposing QProtobufSelfcheckIterator to public API. QProtobufJsonSerializer uses the single QJsonDocument to construct the full JSON data and parse the data received from wire. [ChangeLog][QtProtobuf] The QtProtobufBaseSerializer API is changed. Remove the QProtobufSerializer specifics. [ChangeLog][QtProtobuf] QProtobufSelfcheckIterator is not a part of public API anymore. [ChangeLog][QtProtobufWellKnownTypes][Any] Any type API is changed. 'as' and 'fromMessage' functions not accept the pointer to a serializer. Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: Iddf25bed690e2299c017b3894fc8a3d9306a22b9 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2023-12-08 11:02:21 +00:00
handler.serializer(q_ptr, propertyValue, fieldInfo);
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
Remove the redundant property ordering forwarding from all interfaces QProtobufMessage::propertyOrdering now allows accessing the message property ordering. So we can remove extra arguments from all interfaces where the pointer or the reference to the related QProtobufMessage is used as argument too. [ChangeLog][Protobuf][QAbstractProtobufSerializer] The following interfaces do not accept the QProtobufPropertyOrdering as an argument anymore: - serializeObject - deserializeObject - serializeListObject - deserializeListObject - serializeMessage - deserializeMessage Task-number: QTBUG-120931 Change-Id: I55cb8d3ceddd56751d542869e26aa0de73c22ebb Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-01-26 13:05:04 +00:00
bool QProtobufSerializerPrivate::deserializeProperty(QProtobufMessage *message)
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
{
Remove the redundant property ordering forwarding from all interfaces QProtobufMessage::propertyOrdering now allows accessing the message property ordering. So we can remove extra arguments from all interfaces where the pointer or the reference to the related QProtobufMessage is used as argument too. [ChangeLog][Protobuf][QAbstractProtobufSerializer] The following interfaces do not accept the QProtobufPropertyOrdering as an argument anymore: - serializeObject - deserializeObject - serializeListObject - deserializeListObject - serializeMessage - deserializeMessage Task-number: QTBUG-120931 Change-Id: I55cb8d3ceddd56751d542869e26aa0de73c22ebb Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-01-26 13:05:04 +00:00
Q_ASSERT(message != nullptr);
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
Q_ASSERT(it.isValid() && it.bytesLeft() > 0);
//Each iteration we expect iterator is setup to beginning of next chunk
Add support for the 'oneof' type This patch adds support for 'oneof', a union-like type in protobuf, that need not contain a value, with the following features: - Setting a oneof field will automatically clear all other members of the oneof. - If the parser encounters multiple members of the same oneof on the wire, only the last member seen is used in the parsed message. - A oneof cannot be repeated. - A oneof cannot contain repeated or map fields. - If you set a oneof field to the default value (even the default, such as 0 for an int32 oneof field), the "case" of that oneof field will be set, and the value will be serialized on the wire. Unlike the reference C++ implementation, the Qt implementation of 'oneof' fields adds the 'has<PropertyName>' functions for every 'oneof' member. The protobuf generator generates a Q_PROPERTY for each member of the 'oneof'; these properties are collectively implemented as a single class member. 'oneof' fields are represented by the QtProtobufPrivate::QProtobufOptional class. The class holds the 'oneof' field number and the value that it contains as QVariant. A QExplicitSharedDataPointer is used as reference counter, and to copy and to free the memory of protobuf messages that are stored inside the nested QVariant as pointers. The class could also be used to hold 'optional' fields in follow up commits, but has small overhead since it holds field number, that is not used by optional fields. The generated classes also allows reading field number that is currently stored in the 'oneof' field. The QtProtobuf::InvalidFieldNumber constant indicates that oneof fields is uninitialized. The serialization and deserialization tests use the expected values from the results of the reference C++ serialization(protobuf version 3.19). Task-number: QTBUG-103981 Change-Id: Ie4053cb164bba6bc5f14f8cedb34bad62a638c43 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-12-27 14:23:14 +00:00
int fieldNumber = QtProtobuf::InvalidFieldNumber;
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
QtProtobuf::WireTypes wireType = QtProtobuf::WireTypes::Unknown;
Protobuf: store and re-emit unknown fields Use the unknownEntries variable we so cleverly added in QProtobufMessagePrivate to store the data for the unknown fields. By using a bytes-to-count mapping we can easily store multiple repeated entries of a message, which could happen in a repeated list with multiple identical entries. Since we don't know if a field is actually marked as _repeated_ or not (since it's an unknown field) we just have to assume it is. Fixes: QTBUG-101966 Change-Id: I1ebde5fdaebe2987a68de1632f136bb6606e718a Reviewed-by: Alexey Edelev <alexey.edelev@qt.io>
2022-10-05 17:11:23 +00:00
const QProtobufSelfcheckIterator itBeforeHeader = it; // copy this, we may need it later
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
if (!QProtobufSerializerPrivate::decodeHeader(it, fieldNumber, wireType)) {
setDeserializationError(
QAbstractProtobufSerializer::InvalidHeaderError,
Fix all translate strings It was supposed to be 'translate', not 'tr'. Change-Id: I315285ccc9df1772fdaba8bcd1db658171796140 Reviewed-by: Alexey Edelev <alexey.edelev@qt.io>
2022-12-01 15:12:21 +00:00
QCoreApplication::translate("QtProtobuf",
"Message received doesn't contain valid header byte."));
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
return false;
}
Remove the redundant property ordering forwarding from all interfaces QProtobufMessage::propertyOrdering now allows accessing the message property ordering. So we can remove extra arguments from all interfaces where the pointer or the reference to the related QProtobufMessage is used as argument too. [ChangeLog][Protobuf][QAbstractProtobufSerializer] The following interfaces do not accept the QProtobufPropertyOrdering as an argument anymore: - serializeObject - deserializeObject - serializeListObject - deserializeListObject - serializeMessage - deserializeMessage Task-number: QTBUG-120931 Change-Id: I55cb8d3ceddd56751d542869e26aa0de73c22ebb Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-01-26 13:05:04 +00:00
auto ordering = message->propertyOrdering();
Q_ASSERT(ordering != nullptr);
int index = ordering->indexOfFieldNumber(fieldNumber);
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
if (index == -1) {
Protobuf: store and re-emit unknown fields Use the unknownEntries variable we so cleverly added in QProtobufMessagePrivate to store the data for the unknown fields. By using a bytes-to-count mapping we can easily store multiple repeated entries of a message, which could happen in a repeated list with multiple identical entries. Since we don't know if a field is actually marked as _repeated_ or not (since it's an unknown field) we just have to assume it is. Fixes: QTBUG-101966 Change-Id: I1ebde5fdaebe2987a68de1632f136bb6606e718a Reviewed-by: Alexey Edelev <alexey.edelev@qt.io>
2022-10-05 17:11:23 +00:00
// This is an unknown field, it may have been added in a later revision
// of the Message we are currently deserializing. We must store the
// bytes for this field and re-emit them later if this message is
// serialized again.
qsizetype length = std::distance(itBeforeHeader, it); // size of header
length += QProtobufSerializerPrivate::skipSerializedFieldBytes(it, wireType);
if (!it.isValid()) {
setUnexpectedEndOfStreamError();
return false;
}
Allow skipping unknown fields when deserializing protobuf messages Add the QProtobufSerializer::shouldPreserveUnknownFields function. The function controls whether the unknown fields received from the wire should be stored in the resulting message or should be omitted. Change-Id: I898e67ff4b162bd0e56970a704f7359adeb653e1 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-11-18 12:59:43 +00:00
if (preserveUnknownFields) {
QProtobufMessage: make private ref-counted Avoids unnecessary allocations/deallocations, especially noticeable while detaching lists of protobuf messages. Pick-to: 6.7 Change-Id: I51703075ec8ed1d956da87f5a2636f71b214a440 Reviewed-by: Alexey Edelev <alexey.edelev@qt.io>
2024-02-20 13:56:57 +00:00
message->detachPrivate();
Allow skipping unknown fields when deserializing protobuf messages Add the QProtobufSerializer::shouldPreserveUnknownFields function. The function controls whether the unknown fields received from the wire should be stored in the resulting message or should be omitted. Change-Id: I898e67ff4b162bd0e56970a704f7359adeb653e1 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-11-18 12:59:43 +00:00
QProtobufMessagePrivate *messagePrivate = QProtobufMessagePrivate::get(message);
messagePrivate->storeUnknownEntry(QByteArrayView(itBeforeHeader.data(), length),
fieldNumber);
}
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
return true;
}
Rename QProtobufPropertyOrderingInfo to QProtobufFieldInfo The struct represents the protobuf field information, so rename it accordingly. Task-number: QTBUG-123626 Change-Id: I79605a349f35e73c9fc808c76073d5c1c83c9731 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-18 12:34:47 +00:00
QProtobufFieldInfo fieldInfo(*ordering, index);
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
if (cachedIndex != index) {
if (!storeCachedValue(message))
return false;
cachedPropertyValue = message->property(fieldInfo, true);
cachedIndex = index;
}
QMetaType metaType = cachedPropertyValue.metaType();
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
Add support for the 'oneof' type This patch adds support for 'oneof', a union-like type in protobuf, that need not contain a value, with the following features: - Setting a oneof field will automatically clear all other members of the oneof. - If the parser encounters multiple members of the same oneof on the wire, only the last member seen is used in the parsed message. - A oneof cannot be repeated. - A oneof cannot contain repeated or map fields. - If you set a oneof field to the default value (even the default, such as 0 for an int32 oneof field), the "case" of that oneof field will be set, and the value will be serialized on the wire. Unlike the reference C++ implementation, the Qt implementation of 'oneof' fields adds the 'has<PropertyName>' functions for every 'oneof' member. The protobuf generator generates a Q_PROPERTY for each member of the 'oneof'; these properties are collectively implemented as a single class member. 'oneof' fields are represented by the QtProtobufPrivate::QProtobufOptional class. The class holds the 'oneof' field number and the value that it contains as QVariant. A QExplicitSharedDataPointer is used as reference counter, and to copy and to free the memory of protobuf messages that are stored inside the nested QVariant as pointers. The class could also be used to hold 'optional' fields in follow up commits, but has small overhead since it holds field number, that is not used by optional fields. The generated classes also allows reading field number that is currently stored in the 'oneof' field. The QtProtobuf::InvalidFieldNumber constant indicates that oneof fields is uninitialized. The serialization and deserialization tests use the expected values from the results of the reference C++ serialization(protobuf version 3.19). Task-number: QTBUG-103981 Change-Id: Ie4053cb164bba6bc5f14f8cedb34bad62a638c43 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-12-27 14:23:14 +00:00
qProtoDebug() << "wireType:" << wireType << "metaType:" << metaType.name()
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
<< "currentByte:" << QString::number((*it), 16);
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
if (metaType.flags() & QMetaType::IsPointer) {
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
auto *messageProperty = cachedPropertyValue.value<QProtobufMessage *>();
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
Q_ASSERT(messageProperty != nullptr);
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
return deserializeObject(messageProperty);
Remove message registration in serialization handler map QProtobufMessage::propertyOrdering now provides information about the message property ordering. This allow us to use the pointers to QProtobufMessage but not to the exact class when (de)serializing messages. This commit makes all private getter of message fields mutable. If the message field is not initialized it will be initialized at first access, like it's done in public getters. This mechanism allows to hold the field allocation inside message but not in the type deserializer. All serializers no should expect that the message pointer that is passed to the deserialization is valid message pointer. To avoid unwanted message field allocation when using property getter, QProtobufMessage::property method now accepts an extra argument. If allowInitializeOptional is set to true, it skips checking the 'has<MessageField>' property before accessing the message field it self. Protobuf messages that are used in oneof fields now require explicit definition of operator=, since it's used when copying the data in QVariant. Otherwise the warning related to the implicit definition of operator= is produced. Task-number: QTBUG-120931 Change-Id: I1b816295297e7ef8cd6d3f0abdcbe1e670597fd0 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2024-01-26 08:58:56 +00:00
}
Remove 'get' prefixes of QProtobufPropertyOrdering methods Follow the Qt style in getter naming. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: I8518ee5095fbab88864013c95de23f287ea58c5a Reviewed-by: Dennis Oberst <dennis.oberst@qt.io> Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-05 11:39:15 +00:00
const auto fieldFlags = fieldInfo.fieldFlags();
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
if (fieldFlags.testFlag(QtProtobufPrivate::FieldFlag::Enum)) {
if (fieldFlags.testFlag(QtProtobufPrivate::FieldFlag::Repeated)) {
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
auto intList = cachedPropertyValue.value<QList<QtProtobuf::int64>>();
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
if (deserializeEnumList(intList)) {
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
cachedPropertyValue.setValue(intList);
return true;
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
}
return false;
} else {
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
if (deserializeBasic<QtProtobuf::int64>(it, cachedPropertyValue))
return true;
Rid of the (de)serializeEnumList interface The methods applied the conversion from QList<EnumType> to QList<QtProtobuf::int64>. This can be done on the QMetaType level using the covert function. Add the conversion from/to QList<QtProtobuf::int64> for the QList<EnumType> and the conversion from/to QStringList, which should be used in JSON serialization. Pick-to: 6.8 Task-number: QTBUG-123626 Change-Id: Id0300536a8eda3503540089ba7bc29c1cd249752 Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-05-29 11:24:17 +00:00
return false;
}
Remove QAbstractProtobufSerializer::(de)serializeEnum interface Move the enum detection into the serilaizer implementations. Task-number: QTBUG-123626 Change-Id: I45e5d7b058b08a7489f0f61c5c66ffdbeae8a4ba Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2024-04-27 10:23:41 +00:00
}
Scope the QtProtobufPrivate::FieldFlag enum Covert the QtProtobufPrivate::FieldFlag enum to a enum class. This will ensure that enum values will not conflict in the future. Task-number: QTBUG-123626 Pick-to: 6.8 Change-Id: Ibd4d68ac4b27087e5e9e35ba6e4e28242b2cd893 Reviewed-by: Marc Mutz <marc.mutz@qt.io>
2024-07-08 21:06:43 +00:00
bool isNonPacked = fieldFlags.testFlag(QtProtobufPrivate::FieldFlag::NonPacked);
Fix the deserialization of non-packed lists This fixes the situation when we received the non-packed repeated field from the wire, but the used protobuf schema specifies the field as packed. This situation is possible if the protobuf schema mismatches on on the wire ends. The explicit indication of this situation is the wiretype mismatch. So if the wiretype differs of the expected one that means we need to look for the handler with the 'packed' option opposite to the one is expected by the actual protobuf schema. Pick-to: 6.5 Change-Id: I57bf613410c4031f638533f092fd8d36c592db32 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-29 09:42:12 +00:00
auto basicHandler = findIntegratedTypeHandler(metaType, isNonPacked);
Change the container type of the internal type serializers The list of integrated type serializers is predefined and can be initialized statically. Using std::array allows us to avoid extra allocations and gives us clean and simple static initialization. Change-Id: I04290d3b343487d6967341502c893f76a5044139 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-11-16 11:32:06 +00:00
if (basicHandler) {
Fix the deserialization of non-packed lists This fixes the situation when we received the non-packed repeated field from the wire, but the used protobuf schema specifies the field as packed. This situation is possible if the protobuf schema mismatches on on the wire ends. The explicit indication of this situation is the wiretype mismatch. So if the wiretype differs of the expected one that means we need to look for the handler with the 'packed' option opposite to the one is expected by the actual protobuf schema. Pick-to: 6.5 Change-Id: I57bf613410c4031f638533f092fd8d36c592db32 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-29 09:42:12 +00:00
if (basicHandler->wireType != wireType) {
// If the handler wiretype mismatches the wiretype received from the
// wire that most probably means that we received the list in wrong
// format. This can happen because of mismatch of the field packed
// option in the protobuf schema on the wire ends. Invert the
// isNonPacked flag and try to find the handler one more time to make
// sure that we cover this exceptional case.
// See the conformance tests
// Required.Proto3.ProtobufInput.ValidDataRepeated.*.UnpackedInput
// for details.
basicHandler = findIntegratedTypeHandler(metaType, !isNonPacked);
if (!basicHandler || basicHandler->wireType != wireType) {
setDeserializationError(
QAbstractProtobufSerializer::InvalidHeaderError,
QCoreApplication::translate("QtProtobuf",
"Message received has invalid wiretype for the "
"field number %1. Expected %2, received %3")
.arg(fieldNumber)
Fix potential nullptr dereference in deserializeProperty If we were unable to find a deserializer for a given basic type we would try to print out the wire type of the deserializer. But we didn't necessarily have any. Pick-to: 6.8 6.7 Change-Id: I8ccfc7828afb2d24c9a487ec9a5f88db82c71381 Reviewed-by: Alexey Edelev <alexey.edelev@qt.io>
2024-05-29 22:09:35 +00:00
.arg(basicHandler ? static_cast<int>(basicHandler->wireType) : -1)
Fix the deserialization of non-packed lists This fixes the situation when we received the non-packed repeated field from the wire, but the used protobuf schema specifies the field as packed. This situation is possible if the protobuf schema mismatches on on the wire ends. The explicit indication of this situation is the wiretype mismatch. So if the wiretype differs of the expected one that means we need to look for the handler with the 'packed' option opposite to the one is expected by the actual protobuf schema. Pick-to: 6.5 Change-Id: I57bf613410c4031f638533f092fd8d36c592db32 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-29 09:42:12 +00:00
.arg(static_cast<int>(wireType)));
return false;
}
}
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
if (!basicHandler->deserializer(it, cachedPropertyValue)) {
Add the missing deserializing result check Basic type deserializers return the deserializing result. If result is 'false' that means that there were not enough bytes in the message data buffer. Need to exit the deserialization process and indicate the deserialization error for protobuf serializer. Pick-to: 6.5 6.5.0 Change-Id: I5acebce8afee5260815584db43bb5b13de80312e Reviewed-by: Konrad Kujawa <konrad.kujawa@qt.io> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-03-03 18:51:12 +00:00
setUnexpectedEndOfStreamError();
return false;
}
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
} else {
auto handler = QtProtobufPrivate::findHandler(metaType);
if (!handler.deserializer) {
Add support for the 'oneof' type This patch adds support for 'oneof', a union-like type in protobuf, that need not contain a value, with the following features: - Setting a oneof field will automatically clear all other members of the oneof. - If the parser encounters multiple members of the same oneof on the wire, only the last member seen is used in the parsed message. - A oneof cannot be repeated. - A oneof cannot contain repeated or map fields. - If you set a oneof field to the default value (even the default, such as 0 for an int32 oneof field), the "case" of that oneof field will be set, and the value will be serialized on the wire. Unlike the reference C++ implementation, the Qt implementation of 'oneof' fields adds the 'has<PropertyName>' functions for every 'oneof' member. The protobuf generator generates a Q_PROPERTY for each member of the 'oneof'; these properties are collectively implemented as a single class member. 'oneof' fields are represented by the QtProtobufPrivate::QProtobufOptional class. The class holds the 'oneof' field number and the value that it contains as QVariant. A QExplicitSharedDataPointer is used as reference counter, and to copy and to free the memory of protobuf messages that are stored inside the nested QVariant as pointers. The class could also be used to hold 'optional' fields in follow up commits, but has small overhead since it holds field number, that is not used by optional fields. The generated classes also allows reading field number that is currently stored in the 'oneof' field. The QtProtobuf::InvalidFieldNumber constant indicates that oneof fields is uninitialized. The serialization and deserialization tests use the expected values from the results of the reference C++ serialization(protobuf version 3.19). Task-number: QTBUG-103981 Change-Id: Ie4053cb164bba6bc5f14f8cedb34bad62a638c43 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2022-12-27 14:23:14 +00:00
qProtoWarning() << "No deserializer for type" << metaType.name();
Add JSON serialization and deserialization for Qt Protobuf Also, move basic API for serializers into QProtobufBaseSerializer class - add full basic types JSON serialization/deserialization functionality - add list serialization/deserialization functionality [ChangeLog][Protobuf] Edit existing QProtobufSerializer API, also move serialization/deserialization methods from QProtobufSerializer class into QProtobufBaseSerializer interface, since all of them shall be re-usable for new Json-serializer. Autotests cover: basic types and list serialization; TBD: maps, enums, Any type, OneOf, enumLists will be completed in subsequent tasks Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: I7556308062e8e576d32a371f3cb1d4f694824498 Reviewed-by: 🌴 Alexey Edelev 🌴 <alexey.edelev@qt.io>
2023-11-24 17:07:30 +00:00
QString error
= QString::fromUtf8("No deserializer is registered for type %1")
.arg(QString::fromUtf8(metaType.name()));
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
setDeserializationError(
QAbstractProtobufSerializer::NoDeserializerError,
Add JSON serialization and deserialization for Qt Protobuf Also, move basic API for serializers into QProtobufBaseSerializer class - add full basic types JSON serialization/deserialization functionality - add list serialization/deserialization functionality [ChangeLog][Protobuf] Edit existing QProtobufSerializer API, also move serialization/deserialization methods from QProtobufSerializer class into QProtobufBaseSerializer interface, since all of them shall be re-usable for new Json-serializer. Autotests cover: basic types and list serialization; TBD: maps, enums, Any type, OneOf, enumLists will be completed in subsequent tasks Pick-to: 6.7 Task-number: QTBUG-113731 Change-Id: I7556308062e8e576d32a371f3cb1d4f694824498 Reviewed-by: 🌴 Alexey Edelev 🌴 <alexey.edelev@qt.io>
2023-11-24 17:07:30 +00:00
QCoreApplication::translate("QtProtobuf", error.toUtf8().data()));
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
return false;
}
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
handler.deserializer(q_ptr, cachedPropertyValue);
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
Cache property values when deserializing them When deserializing protobuf messages, cache the property values in the serializer. The cached value life-time is limited by field number change. This improves the performance of the deserializer when deserializing repeated fields. So before storing the new value into the message we first collect all values of the repeated field that we received from the wire and only when we recognize the change of the field in the byte stream, update the property value. Fixes: QTBUG-124594 Pick-to: 6.8 6.7 Change-Id: I5ce5d5c81bf0f7ebf071b5ad374a46787b2767e8 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-10 20:14:05 +00:00
return true;
}
bool QProtobufSerializerPrivate::storeCachedValue(QProtobufMessage *message)
{
bool ok = true;
if (cachedIndex >= 0 && !cachedPropertyValue.isNull()) {
const auto *ordering = message->propertyOrdering();
QProtobufFieldInfo fieldInfo(*ordering, cachedIndex);
ok = message->setProperty(fieldInfo, cachedPropertyValue);
cachedPropertyValue.clear();
cachedIndex = -1;
}
return ok;
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
}
Update the documentation for the deserializationError(String) Move the docs to the actual function implementations and adjust the text to the one is used in the QAbstractProtobufSerializer. Pick-to: 6.8 6.7 Change-Id: Ie7aa366e4b9a77c6c45d5a96fe627f50cb3f9df6 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-19 08:38:42 +00:00
/*!
Returns the last deserialization error for the serializer instance.
\sa deserializationErrorString()
*/
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
QAbstractProtobufSerializer::DeserializationError QProtobufSerializer::deserializationError() const
{
return d_ptr->deserializationError;
}
Update the documentation for the deserializationError(String) Move the docs to the actual function implementations and adjust the text to the one is used in the QAbstractProtobufSerializer. Pick-to: 6.8 6.7 Change-Id: Ie7aa366e4b9a77c6c45d5a96fe627f50cb3f9df6 Reviewed-by: Dennis Oberst <dennis.oberst@qt.io>
2024-07-19 08:38:42 +00:00
/*!
Returns the last deserialization error string for the serializer instance.
\sa deserializationError()
*/
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
QString QProtobufSerializer::deserializationErrorString() const
{
return d_ptr->deserializationErrorString;
}
void QProtobufSerializerPrivate::setDeserializationError(
QAbstractProtobufSerializer::DeserializationError error, const QString &errorString)
{
deserializationError = error;
deserializationErrorString = errorString;
}
Allow skipping unknown fields when deserializing protobuf messages Add the QProtobufSerializer::shouldPreserveUnknownFields function. The function controls whether the unknown fields received from the wire should be stored in the resulting message or should be omitted. Change-Id: I898e67ff4b162bd0e56970a704f7359adeb653e1 Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
2023-11-18 12:59:43 +00:00
/*!
Controls whether the unknown fields received from the wire should be
stored in the resulting message or if it should be omitted, based
on \a preserveUnknownFields.
\since 6.7
*/
void QProtobufSerializer::shouldPreserveUnknownFields(bool preserveUnknownFields)
{
d_ptr->preserveUnknownFields = preserveUnknownFields;
}
Long Live QProtobuf The code handles serialization and deserialization by itself with no extra dependencies. It also contains a system for registering converters specific to Protobuf serialization as well as having the ability to extend it to handle JSON encoding[0] in the future, using QJson. This patch is a companion to the patch introducing the qtprotobufgen tool. The code was originally written by Alexey Edelev, along with various contributors, on GitHub. Originally under MIT license, but major contributors have agreed to relicense the code under LGPL/GPL/commercial for inclusion in Qt. Their copyright notice is retained and the original source code, still licensed as MIT, can be found in its original repository[1]. [0]: https://developers.google.com/protocol-buffers/docs/proto3#json [1]: https://github.com/semlanik/qtprotobuf Done-with: Alexey Edelev <alexey.edelev@qt.io> Change-Id: I8b2e7074a19f39bd52ab263e215d2e99ffaf1162 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Tatiana Borisova <tatiana.borisova@qt.io>
2022-10-05 17:11:30 +00:00
QT_END_NAMESPACE