Revision control
++ // Copyright (C) 2022 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include <QtProtobuf/qprotobufmessage.h>
++
++ #include <QtProtobuf/private/qprotobufmessage_p.h>
++ #include <QtProtobuf/private/qprotobufpropertyorderingbuilder_p.h>
++ #include <QtProtobuf/qabstractprotobufserializer.h>
++ #include <QtProtobuf/qprotobufpropertyordering.h>
++
++ #include <QtCore/qassert.h>
++ #include <QtCore/qmetaobject.h>
++
++ #include <QtCore/private/qmetaobjectbuilder_p.h>
++
++ #include <string>
++
++ QT_BEGIN_NAMESPACE
++
++ static std::string nullTerminate(QLatin1StringView l1) noexcept
++ {
++ return l1.isNull() ? std::string{} : std::string{l1.data(), size_t(l1.size())};
++ }
++
++ /*!
++ \since 6.11
++ \fn template <class To> To qprotobufmessage_cast(QProtobufMessage *from)
++ \fn template <class To> To qprotobufmessage_cast(const QProtobufMessage *from)
++ \relates QProtobufMessage
++
++ Returns the given \a from object cast to pointer type \c To if the object is
++ of type \c To (or a subclass); otherwise returns \nullptr. If \a from is
++ \nullptr, this function also returns \nullptr.
++
++ The template argument \c To must be a pointer to a class that inherits from
++ QProtobufMessage and is declared with the \l Q_PROTOBUF_OBJECT macro.
++
++ Example:
++ \code
++ QProtobufMessage *message = new myproject::MySpecificMessage();
++
++ // Cast to its own type (success)
++ auto *specific = qprotobufmessage_cast<myproject::MySpecificMessage *>(message);
++ // specific is a valid pointer
++
++ // Cast to an unrelated type (failure)
++ auto *another = qprotobufmessage_cast<myproject::AnotherMessage *>(message);
++ // another is nullptr
++ \endcode
++
++ This function behaves similarly to the standard C++ \c dynamic_cast(), with
++ the advantages that it doesn't require RTTI support and works across
++ dynamic library boundaries.
++
++ \warning If the type pointed to by \c To is not declared with the
++ Q_PROTOBUF_OBJECT macro, this function's return value is undefined.
++ */
++
++ /*!
++ \class QProtobufMessage
++ \inmodule QtProtobuf
++
++ \brief Base class for all protobuf messages.
++
++ Provides access to the properties of a message, using setProperty()
++ and property(), without depending on what the message is.
++ */
++
++ /*!
++ \internal
++ Used from generated classes to construct the QProtobufMessage base class.
++ Internally the \a metaObject is used to query QMetaProperty
++ */
++ QProtobufMessage::QProtobufMessage(const QMetaObject *metaObject,
++ const QtProtobufPrivate::QProtobufPropertyOrdering *ordering)
++ : d_ptr(new QProtobufMessagePrivate(metaObject, ordering))
++ {
++ }
++
++ /*!
++ \internal
++ Allows constructing QProtobufMessage using the private message implementation from the
++ derived class.
++ */
++ QProtobufMessage::QProtobufMessage(QProtobufMessagePrivate &dd) : d_ptr(&dd)
++ {
++ }
++
++ QT_DEFINE_QESDP_SPECIALIZATION_DTOR(QProtobufMessagePrivate)
++
++ QProtobufMessagePrivate::QProtobufMessagePrivate(const QMetaObject *metaObject,
++ const QtProtobufPrivate::QProtobufPropertyOrdering
++ *ordering)
++ : metaObject(metaObject), ordering(ordering)
++ {
++ }
++
++ QProtobufMessagePrivate::~QProtobufMessagePrivate()
++ = default;
++
++ /*!
++ \internal
++ */
++ int QProtobufMessagePrivate::propertyIndex(QAnyStringView propertyName) const
++ {
++ return propertyName.visit([this](auto propertyName) {
++ if constexpr (std::is_same_v<QStringView, decltype(propertyName)>) {
++ return metaObject->indexOfProperty(propertyName.toLatin1().constData());
++ } else if constexpr (std::is_same_v<QUtf8StringView, decltype(propertyName)>) {
++ return metaObject->indexOfProperty(propertyName.toString().toLatin1().constData());
++ } else if constexpr (std::is_same_v<QLatin1StringView, decltype(propertyName)>) {
++ return metaObject->indexOfProperty(nullTerminate(propertyName).data());
++ }
++ return -1;
++ });
++ }
++
++ void QProtobufMessagePrivate::storeUnknownEntry(QProtobufMessage *message,
++ QByteArrayView entry, int fieldNumber)
++ {
++ Q_ASSERT(message);
++ message->d_ptr.detach();
++ message->d_ptr->unknownEntries[fieldNumber].append(entry.toByteArray());
++ }
++
++ std::optional<QMetaProperty> QProtobufMessagePrivate::metaProperty(QAnyStringView name) const
++ {
++ const int index = propertyIndex(name);
++ const QMetaProperty property = metaObject->property(index);
++ if (property.isValid())
++ return property;
++ return std::nullopt;
++ }
++
++ std::optional<QMetaProperty>
++ QProtobufMessagePrivate::metaProperty(QtProtobufPrivate::QProtobufFieldInfo info) const
++ {
++ const int propertyIndex = info.propertyIndex() + metaObject->propertyOffset();
++ const QMetaProperty metaProperty = metaObject->property(propertyIndex);
++ if (metaProperty.isValid())
++ return metaProperty;
++ return std::nullopt;
++ }
++
++ /*!
++ Set the property \a propertyName to the value stored in \a value.
++
++ If the \a propertyName isn't a known fields, then the value is ignored, and
++ the function returns \c false.
++
++ Returns \c false if it fails to store the \a value on the property.
++ Otherwise \c{true}.
++ */
++ bool QProtobufMessage::setProperty(QAnyStringView propertyName, const QVariant &value)
++ {
++ Q_D(QProtobufMessage);
++
++ if (auto mp = d->metaProperty(propertyName))
++ return mp->writeOnGadget(this, value);
++
++ return false;
++ }
++
++ /*!
++ \overload
++ \since 6.6
++ */
++ bool QProtobufMessage::setProperty(QAnyStringView propertyName, QVariant &&value)
++ {
++ Q_D(QProtobufMessage);
++
++ if (auto mp = d->metaProperty(propertyName))
++ return mp->writeOnGadget(this, std::move(value));
++
++ return false;
++ }
++
++ /*!
++ Get the value of the property \a propertyName.
++
++ If the \a propertyName isn't known then the returned QVariant is invalid.
++ */
++ QVariant QProtobufMessage::property(QAnyStringView propertyName) const
++ {
++ Q_D(const QProtobufMessage);
++
++ if (const auto mp = d->metaProperty(propertyName))
++ return mp->readOnGadget(this);
++ return {};
++ }
++
++ /*!
++ \internal
++ */
++ QProtobufMessage::QProtobufMessage(const QProtobufMessage &other)
++ = default;
++
++ /*!
++ \internal
++ */
++ QProtobufMessage &QProtobufMessage::operator=(const QProtobufMessage &other)
++ = default;
++
++
++ /*!
++ \internal
++ */
++ QProtobufMessage::~QProtobufMessage()
++ = default;
++
++ /*!
++ \since 6.8
++ Returns the pointer to the property ordering of the derived protobuf message.
++ */
++ const QtProtobufPrivate::QProtobufPropertyOrdering *QProtobufMessage::propertyOrdering() const
++ {
++ Q_D(const QProtobufMessage);
++ return d->ordering;
++ }
++
++ /*!
++ \internal
++ */
++ bool comparesEqual(const QProtobufMessage &lhs, const QProtobufMessage &rhs) noexcept
++ {
++ if (lhs.d_ptr == rhs.d_ptr)
++ return true;
++ return lhs.d_func()->unknownEntries == rhs.d_func()->unknownEntries;
++ }
++
++ /*!
++ \internal
++ \since 6.11
++ Returns a pointer to the meta-object for this message instance. The
++ meta-object provides run-time type information for dynamic operations.
++
++ \sa qprotobufmessage_cast()
++ */
++ const QMetaObject *QProtobufMessage::metaObject() const
++ {
++ Q_D(const QProtobufMessage);
++ return d->metaObject;
++ }
++
++ namespace QtProtobufPrivate {
++ /*!
++ \internal
++ */
++ extern QProtobufMessagePointer constructMessageByName(const QString &messageType);
++ }
++
++ /*!
++ Constructs QProtobufMessage using \a messageType.
++ Returns a pointer to the constructed QProtobufMessage.
++
++ This function attempts to create a message with a type that matches \a messageType.
++ If \a messageType is unknown, the function returns \nullptr. If the message
++ is not found in the registry, the function returns \nullptr.
++ The function caller is given ownership of the constructed message.
++ */
++ QProtobufMessagePointer QProtobufMessage::constructByName(const QString &messageType)
++ {
++ return QtProtobufPrivate::constructMessageByName(messageType);
++ }
++
++ /*!
++ \typedef QProtobufMessagePointer
++ \relates QProtobufMessage
++ \inmodule QtProtobuf
++
++ Synonym for std::unique_ptr<QProtobufMessage, QProtobufMessageDeleter>.
++ Use this to manage the lifetime of dynamically allocated QProtobufMessages,
++ such as those created by calling QProtobufMessage::constructByName.
++ */
++
++ /*!
++ \class QProtobufMessageDeleter
++ \inmodule QtProtobuf
++ \brief Calls the destructor of the child class of a QProtobufMessage.
++
++ This class calls the destructor of a protobuf message using the meta-type
++ system. It is intended to be used with smart pointers, such as std::unique_ptr.
++
++ \sa QProtobufMessagePointer
++ */
++
++ /*!
++ Destroys the message pointed to by \a ptr.
++ This is intended for use with smart pointers.
++
++ \sa QProtobufMessagePointer
++ */
++ void QProtobufMessageDeleter::operator()(QProtobufMessage *ptr) const noexcept
++ {
++ if (!ptr)
++ return;
++ const QMetaObject *mobj = ptr->d_ptr->metaObject;
++ QMetaType type = mobj->metaType();
++ type.destroy(ptr);
++ }
++
++ /*!
++ Returns the field numbers that were not known to QtProtobuf during
++ deserialization.
++ \since 6.7
++ */
++ QList<qint32> QProtobufMessage::unknownFieldNumbers() const
++ {
++ Q_D(const QProtobufMessage);
++ return d->unknownEntries.keys();
++ }
++
++ /*!
++ Returns the unknown \a field values sorted as they were received from the
++ wire.
++ \since 6.7
++ */
++ QList<QByteArray> QProtobufMessage::unknownFieldData(qint32 field) const
++ {
++ Q_D(const QProtobufMessage);
++ return d->unknownEntries.value(field);
++ }
++
++ /*!
++ \since 6.8
++ Serializes this protobuf message into a QByteArray using \a serializer.
++
++ \sa deserialize()
++ */
++ QByteArray QProtobufMessage::serialize(QAbstractProtobufSerializer *serializer) const
++ {
++ return serializer->serialize(this);
++ }
++
++ /*!
++ \since 6.8
++ Deserializes this protobuf message from a QByteArray \a data using
++ \a serializer.
++ Returns \c true if deserialization was successful, otherwise \c false.
++
++ \sa serialize()
++ */
++ bool QProtobufMessage::deserialize(QAbstractProtobufSerializer *serializer, QByteArrayView data)
++ {
++ return serializer->deserialize(this, data);
++ }
++
++ static bool isProtobufMessage(QMetaType type)
++ {
++ if (const auto *mo = type.metaObject(); mo && mo->inherits(&QProtobufMessage::staticMetaObject))
++ return true;
++ return false;
++ }
++
++ using StaticMetaCallFn = void (*)(QObject *, QMetaObject::Call, int, void **);
++ QMetaObject *buildMetaObject(QMetaType key, QMetaType value, StaticMetaCallFn metaCall)
++ {
++ using namespace Qt::StringLiterals;
++ QMetaObjectBuilder builder;
++ builder.addProperty("key", key.name(), key);
++ if (isProtobufMessage(key)) {
++ auto propBuilder = builder.addProperty("has_key", "bool", QMetaType(QMetaType::Bool));
++ propBuilder.setWritable(false);
++ }
++ builder.addProperty("value", value.name(), value);
++ if (isProtobufMessage(value)) {
++ auto propBuilder = builder.addProperty("has_value", "bool", QMetaType(QMetaType::Bool));
++ propBuilder.setWritable(false);
++ }
++ builder.setClassName("QProtobufMapEntry<"_ba + key.name() + ", " + value.name() + '>');
++ builder.setSuperClass(&QProtobufMapEntryBase::staticMetaObject);
++ builder.setStaticMetacallFunction(metaCall);
++ builder.setFlags(MetaObjectFlag::PropertyAccessInStaticMetaCall);
++ return builder.toMetaObject();
++ }
++
++ QtProtobufPrivate::FieldFlags getFlagForType(QMetaType type)
++ {
++ using FieldFlag = QtProtobufPrivate::FieldFlag;
++ QtProtobufPrivate::FieldFlags flag = {};
++
++ if (isProtobufMessage(type))
++ flag |= FieldFlag::Message | FieldFlag::ExplicitPresence;
++ if (type.flags() & QMetaType::IsEnumeration)
++ flag |= FieldFlag::Enum;
++ if (QByteArrayView(type.name()).startsWith("QList<")) // Surely there's a better way
++ flag |= FieldFlag::Repeated;
++ if (QByteArrayView(type.name()).startsWith("QHash<")) // Surely there's a better way
++ flag |= FieldFlag::Map;
++
++ flag |= FieldFlag::Optional; // Hardcoded for MapEntry uses...
++
++ // Need to get this info::
++ // NonPacked = 0x1,
++ // Oneof = 0x02,
++ // Optional = 0x04,
++ // Repeated = 0x40,
++ // Map = 0x80,
++
++ return flag;
++ }
++
++ QtProtobufPrivate::QProtobufPropertyOrdering::Data *buildMapEntryOrdering(QMetaType key,
++ QMetaType value)
++ {
++ using namespace QtProtobufPrivate;
++ QProtobufPropertyOrderingBuilder builder("MapEntry");
++
++ const auto keyFlags = getFlagForType(key);
++ builder.addV0Field("key", 1, 0, keyFlags);
++
++ const uint valueIndex = keyFlags.testFlag(FieldFlag::ExplicitPresence) ? 2 : 1;
++ builder.addV0Field("value", 2, valueIndex, getFlagForType(value));
++
++ return builder.build();
++ }
++
++ class QProtobufMapEntryBasePrivate : public QProtobufMessagePrivate
++ {
++ Q_DISABLE_COPY_MOVE(QProtobufMapEntryBasePrivate)
++ public:
++ QProtobufMapEntryBasePrivate(QMetaType key, QMetaType value, StaticMetaCallFn metaCall);
++ ~QProtobufMapEntryBasePrivate() override;
++
++ QtProtobufPrivate::QProtobufPropertyOrdering::Data *data = nullptr;
++ QtProtobufPrivate::QProtobufPropertyOrdering mutableOrdering{};
++ QMetaObject *mutableMetaObject = nullptr;
++ };
++
++ QProtobufMapEntryBase::QProtobufMapEntryBase(QMetaType key, QMetaType value,
++ StaticMetaCallFn metaCall)
++ : QProtobufMessage(*new QProtobufMapEntryBasePrivate(key, value, metaCall))
++ {
++ }
++
++ QProtobufMapEntryBasePrivate::QProtobufMapEntryBasePrivate(QMetaType key, QMetaType value,
++ StaticMetaCallFn metaCall)
++ : QProtobufMessagePrivate(),
++ data(buildMapEntryOrdering(key, value)),
++ mutableMetaObject(buildMetaObject(key, value, metaCall))
++ {
++ mutableOrdering.data = data;
++ QProtobufMessagePrivate::ordering = &mutableOrdering;
++ QProtobufMessagePrivate::metaObject = mutableMetaObject;
++ }
++
++ QProtobufMapEntryBase::~QProtobufMapEntryBase()
++ = default;
++
++ QProtobufMapEntryBasePrivate::~QProtobufMapEntryBasePrivate()
++ {
++ data->~Data();
++ free(data);
++ free(mutableMetaObject);
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qprotobufmessage.cpp"