qrestaccessmanager.cpp

Go to the documentation of this file.

// Copyright (C) 2023 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 "qrestaccessmanager.h"
#include "qrestaccessmanager_p.h"
#include "qrestreply.h"
 
#include <QtNetwork/qhttpmultipart.h>
#include <QtNetwork/qnetworkaccessmanager.h>
#include <QtNetwork/qnetworkreply.h>
 
#include <QtCore/qjsondocument.h>
#include <QtCore/qjsonobject.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qthread.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
Q_LOGGING_CATEGORY(lcQrest, "qt.network.access.rest")
 
 
QRestAccessManager::QRestAccessManager(QNetworkAccessManager *manager, QObject *parent)
    : QObject(*new QRestAccessManagerPrivate, parent)
{
    Q_D(QRestAccessManager);
    d->qnam = manager;
    if (!d->qnam)
        qCWarning(lcQrest, "QRestAccessManager: QNetworkAccesManager is nullptr");
}
 
QRestAccessManager::~QRestAccessManager()
    = default;
 
QNetworkAccessManager *QRestAccessManager::networkAccessManager() const
{
    Q_D(const QRestAccessManager);
    return d->qnam;
}
 
QRestAccessManagerPrivate::QRestAccessManagerPrivate()
    = default;
 
QRestAccessManagerPrivate::~QRestAccessManagerPrivate()
{
    if (!activeRequests.isEmpty()) {
        qCWarning(lcQrest, "Access manager destroyed while %lld requests were still in progress",
                  qlonglong(activeRequests.size()));
    }
}
 
QNetworkReply *QRestAccessManager::postWithDataImpl(const QNetworkRequest &request,
                                                 const QJsonDocument &data, const QObject *context,
                                                 QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([](auto qnam, auto req, auto data) { return qnam->post(req, data); },
                             data, request, context, slot);
}
 
QNetworkReply *QRestAccessManager::postWithDataImpl(const QNetworkRequest &request,
                                                 const QVariantMap &data, const QObject *context,
                                                 QtPrivate::QSlotObjectBase *slot)
{
    return postWithDataImpl(request, QJsonDocument::fromVariant(data), context, slot);
}
 
QNetworkReply *QRestAccessManager::postWithDataImpl(const QNetworkRequest &request,
                                                 const QByteArray &data, const QObject *context,
                                                 QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->post(request, data); }, context, slot);
}
 
QNetworkReply *QRestAccessManager::postWithDataImpl(const QNetworkRequest &request,
                                                 QHttpMultiPart *data, const QObject *context,
                                                 QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->post(request, data); }, context, slot);
}
 
QNetworkReply *QRestAccessManager::postWithDataImpl(const QNetworkRequest &request,
                                                 QIODevice *data, const QObject *context,
                                                 QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->post(request, data); }, context, slot);
}
 
QNetworkReply *QRestAccessManager::getNoDataImpl(const QNetworkRequest &request,
                                     const QObject *context, QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->get(request); }, context, slot);
}
 
QNetworkReply *QRestAccessManager::getWithDataImpl(const QNetworkRequest &request,
                                                const QByteArray &data, const QObject *context,
                                                QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->get(request, data); }, context, slot);
}
 
QNetworkReply *QRestAccessManager::getWithDataImpl(const QNetworkRequest &request,
                                                const QJsonDocument &data, const QObject *context,
                                                QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([](auto qnam, auto req, auto data) { return qnam->get(req, data); },
                             data, request, context, slot);
}
 
QNetworkReply *QRestAccessManager::getWithDataImpl(const QNetworkRequest &request,
                                                QIODevice *data, const QObject *context,
                                                QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->get(request, data); }, context, slot);
}
 
QNetworkReply *QRestAccessManager::deleteResourceNoDataImpl(const QNetworkRequest &request,
                                     const QObject *context, QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->deleteResource(request); }, context, slot);
}
 
QNetworkReply *QRestAccessManager::headNoDataImpl(const QNetworkRequest &request,
                                     const QObject *context, QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->head(request); }, context, slot);
}
 
QNetworkReply *QRestAccessManager::putWithDataImpl(const QNetworkRequest &request,
                                                const QJsonDocument &data, const QObject *context,
                                                QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([](auto qnam, auto req, auto data) { return qnam->put(req, data); },
                             data, request, context, slot);
}
 
QNetworkReply *QRestAccessManager::putWithDataImpl(const QNetworkRequest &request,
                                                const QVariantMap &data, const QObject *context,
                                                QtPrivate::QSlotObjectBase *slot)
{
    return putWithDataImpl(request, QJsonDocument::fromVariant(data), context, slot);
}
 
QNetworkReply *QRestAccessManager::putWithDataImpl(const QNetworkRequest &request,
                                                const QByteArray &data, const QObject *context,
                                                QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->put(request, data); }, context, slot);
}
 
QNetworkReply *QRestAccessManager::putWithDataImpl(const QNetworkRequest &request,
                                                QHttpMultiPart *data, const QObject *context,
                                                QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->put(request, data); }, context, slot);
}
 
QNetworkReply *QRestAccessManager::putWithDataImpl(const QNetworkRequest &request, QIODevice *data,
                                     const QObject *context, QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->put(request, data); }, context, slot);
}
 
static const auto PATCH = "PATCH"_ba;
 
QNetworkReply *QRestAccessManager::patchWithDataImpl(const QNetworkRequest &request,
                                                const QJsonDocument &data, const QObject *context,
                                                QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest(
           [](auto qnam, auto req, auto data) { return qnam->sendCustomRequest(req, PATCH, data); },
           data, request, context, slot);
}
 
QNetworkReply *QRestAccessManager::patchWithDataImpl(const QNetworkRequest &request,
                                                const QVariantMap &data, const QObject *context,
                                                QtPrivate::QSlotObjectBase *slot)
{
    return patchWithDataImpl(request, QJsonDocument::fromVariant(data), context, slot);
}
 
QNetworkReply *QRestAccessManager::patchWithDataImpl(const QNetworkRequest &request,
                                                const QByteArray &data, const QObject *context,
                                                QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->sendCustomRequest(request, PATCH, data); },
                             context, slot);
}
 
QNetworkReply *QRestAccessManager::patchWithDataImpl(const QNetworkRequest &request, QIODevice *data,
                                           const QObject *context, QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->sendCustomRequest(request, PATCH, data); },
                             context, slot);
}
 
QNetworkReply *QRestAccessManager::customWithDataImpl(const QNetworkRequest &request,
                                                   const QByteArray& method, const QByteArray &data,
                                                   const QObject *context,
                                                   QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->sendCustomRequest(request, method, data); },
                             context, slot);
}
 
QNetworkReply *QRestAccessManager::customWithDataImpl(const QNetworkRequest &request,
                                                   const QByteArray& method, QIODevice *data,
                                                   const QObject *context,
                                                   QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->sendCustomRequest(request, method, data); },
                             context, slot);
}
 
QNetworkReply *QRestAccessManager::customWithDataImpl(const QNetworkRequest &request,
                                                   const QByteArray& method, QHttpMultiPart *data,
                                                   const QObject *context,
                                                   QtPrivate::QSlotObjectBase *slot)
{
    Q_D(QRestAccessManager);
    return d->executeRequest([&](auto qnam) { return qnam->sendCustomRequest(request, method, data); },
                             context, slot);
}
 
QNetworkReply *QRestAccessManagerPrivate::createActiveRequest(QNetworkReply *reply,
                                                    const QObject *contextObject,
                                                    QtPrivate::QSlotObjectBase *slot)
{
    Q_Q(QRestAccessManager);
    Q_ASSERT(reply);
    QtPrivate::SlotObjSharedPtr slotPtr(QtPrivate::SlotObjUniquePtr{slot}); // adopts
    activeRequests.insert(reply, CallerInfo{contextObject, slotPtr});
    // The signal connections below are made to 'q' to avoid stray signal
    // handling upon its destruction while requests were still in progress
 
    QObject::connect(reply, &QNetworkReply::finished, q, [reply, this]() {
        handleReplyFinished(reply);
    });
    // Safe guard in case reply is destroyed before it's finished
    QObject::connect(reply, &QObject::destroyed, q, [reply, this]() {
        activeRequests.remove(reply);
    });
    // If context object is destroyed, clean up any possible replies it had associated with it
    if (contextObject) {
        QObject::connect(contextObject, &QObject::destroyed, q, [reply, this]() {
            activeRequests.remove(reply);
        });
    }
    return reply;
}
 
void QRestAccessManagerPrivate::verifyThreadAffinity(const QObject *contextObject)
{
    Q_Q(QRestAccessManager);
    if (QThread::currentThread() != q->thread()) {
        qCWarning(lcQrest, "QRestAccessManager can only be called in the thread it belongs to");
        Q_ASSERT(false);
    }
    if (contextObject && (contextObject->thread() != q->thread())) {
        qCWarning(lcQrest, "QRestAccessManager: the context object must reside in the same thread");
        Q_ASSERT(false);
    }
}
 
QNetworkReply* QRestAccessManagerPrivate::warnNoAccessManager()
{
    qCWarning(lcQrest, "QRestAccessManager: QNetworkAccessManager not set");
    return nullptr;
}
 
void QRestAccessManagerPrivate::handleReplyFinished(QNetworkReply *reply)
{
    auto request = activeRequests.find(reply);
    if (request == activeRequests.end()) {
        qCDebug(lcQrest, "QRestAccessManager: Unexpected reply received, ignoring");
        return;
    }
 
    CallerInfo caller = request.value();
    activeRequests.erase(request);
 
    if (caller.slot) {
        // Callback was provided
        QRestReply restReply(reply);
        void *argv[] = { nullptr, &restReply };
        // If we have context object, use it
        QObject *context = caller.contextObject
                ? const_cast<QObject*>(caller.contextObject.get()) : nullptr;
        caller.slot->call(context, argv);
    }
}
 
QT_END_NAMESPACE
 
#include "moc_qrestaccessmanager.cpp"