restreply.h

#ifndef QTRESTCLIENT_RESTREPLY_H
#define QTRESTCLIENT_RESTREPLY_H
 
#include "QtRestClient/qtrestclient_global.h"
#include "QtRestClient/qtrestclient_helpertypes.h"
 
#include <functional>
#include <chrono>
 
#ifdef QT_RESTCLIENT_USE_ASYNC
#include <QtCore/QThreadPool>
#include <QtCore/QFuture>
#endif
 
#include <QtNetwork/qnetworkreply.h>
 
namespace QtRestClient {
 
class RestReplyPrivate;
class RestReplyAwaitable;
class QmlGenericRestReply; //needed for QML bindings
class Q_RESTCLIENT_EXPORT RestReply : public QObject
{
    Q_OBJECT
 
    Q_PROPERTY(bool autoDelete READ autoDelete WRITE setAutoDelete NOTIFY autoDeleteChanged)
    Q_PROPERTY(bool allowEmptyReplies READ allowsEmptyReplies WRITE setAllowEmptyReplies NOTIFY allowEmptyRepliesChanged)
#ifdef QT_RESTCLIENT_USE_ASYNC
    Q_PROPERTY(bool async READ isAsync WRITE setAsync NOTIFY asyncChanged)
#endif
 
public:
#ifdef DOXYGEN_RUN
    using DataType = std::variant<std::nullopt_t, QCborValue, QJsonValue>;
#else
    using DataType = __private::__binder::DataType;
#endif
 
    enum class Error {
        //default error types
        Network,  
        Parser,  
        Failure,  
 
        //extended error types
        Deserialization  
    };
    Q_ENUM(Error)
 
    
    RestReply(QNetworkReply *networkReply, QObject *parent = nullptr);
#ifdef QT_RESTCLIENT_USE_ASYNC
    RestReply(const QFuture<QNetworkReply*> &networkReplyFuture, QObject *parent = nullptr);
    RestReply(QNetworkReply *networkReply, QThreadPool *asyncPool, QObject *parent = nullptr);
    RestReply(const QFuture<QNetworkReply*> &networkReplyFuture, QThreadPool *asyncPool, QObject *parent = nullptr);
#endif
    ~RestReply() override;
 
    template <typename TFn>
    RestReply *onSucceeded(TFn &&handler);
    template <typename TFn>
    RestReply *onSucceeded(QObject *scope, TFn &&handler);
    template <typename TFn>
    RestReply *onFailed(TFn &&handler);
    template <typename TFn>
    RestReply *onFailed(QObject *scope, TFn &&handler);
    template <typename TFn>
    RestReply *onCompleted(TFn &&handler);
    template <typename TFn>
    RestReply *onCompleted(QObject *scope, TFn &&handler);
 
    RestReply *onError(std::function<void(QString, int, Error)> handler);
    RestReply *onError(QObject *scope, std::function<void(QString, int, Error)> handler);
 
    RestReply *onAllErrors(const std::function<void(QString, int, Error)> &handler);
    RestReply *onAllErrors(QObject *scope,
                           const std::function<void(QString, int, Error)> &handler);
    template <typename TFn>
    RestReply *onAllErrors(const std::function<void(QString, int, Error)> &handler,
                           TFn &&failureTransformer);
    template <typename TFn>
    RestReply *onAllErrors(QObject *scope,
                           const std::function<void(QString, int, Error)> &handler,
                           TFn &&failureTransformer);
 
#ifdef QT_RESTCLIENT_USE_ASYNC
    Q_INVOKABLE RestReply *makeAsync(QThreadPool *threadPool = QThreadPool::globalInstance());
#endif
    Q_INVOKABLE inline RestReply *disableAutoDelete() {
        setAutoDelete(false);
        return this;
    }
 
    bool autoDelete() const;
    bool allowsEmptyReplies() const;
#ifdef QT_RESTCLIENT_USE_ASYNC
    bool isAsync() const;
#endif
 
    Q_INVOKABLE QNetworkReply *networkReply() const;
 
    RestReplyAwaitable awaitable();
 
public Q_SLOTS:
    void abort();
    void retry();
    void retryAfter(std::chrono::milliseconds mSecs);
 
    void setAutoDelete(bool autoDelete);
    void setAllowEmptyReplies(bool allowEmptyReplies);
#ifdef QT_RESTCLIENT_USE_ASYNC
    void setAsync(bool async);
#endif
 
Q_SIGNALS:
    void completed(int httpStatus, const DataType &reply, QPrivateSignal);
    void succeeded(int httpStatus, const DataType &reply, QPrivateSignal);
    void failed(int httpStatus, const DataType &reason, QPrivateSignal);
    void error(const QString &errorString, int error, Error errorType, QPrivateSignal);
 
    void networkError(QNetworkReply::NetworkError error);
#ifndef QT_NO_SSL
    void sslErrors(const QList<QSslError> &errors, bool &ignoreErrors);
#endif
 
    void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
    void uploadProgress(qint64 bytesSent, qint64 bytesTotal);
 
    void autoDeleteChanged(bool autoDelete, QPrivateSignal);
    void allowEmptyRepliesChanged(bool allowEmptyReplies, QPrivateSignal);
#ifdef QT_RESTCLIENT_USE_ASYNC
    void asyncChanged(bool async, QPrivateSignal);
#endif
 
protected:
    RestReply(RestReplyPrivate &dd, QObject *parent = nullptr);
 
private:
    Q_DECLARE_PRIVATE(RestReply)
 
    Qt::ConnectionType callbackType() const;
 
    Q_PRIVATE_SLOT(d_func(), void _q_replyFinished())
    Q_PRIVATE_SLOT(d_func(), void _q_retryReply())
#ifndef QT_NO_SSL
    Q_PRIVATE_SLOT(d_func(), void _q_handleSslErrors(const QList<QSslError> &))
#endif
};
 
template<typename TFn>
RestReply *RestReply::onSucceeded(TFn &&handler)
{
    return onSucceeded(this, std::forward<TFn>(handler));
}
 
template<typename TFn>
RestReply *RestReply::onSucceeded(QObject *scope, TFn &&handler)
{
    connect(this, &RestReply::succeeded,
            scope, __private::bindCallback(std::forward<TFn>(handler)),
            callbackType());
    return this;
}
 
template<typename TFn>
RestReply *RestReply::onFailed(TFn &&handler)
{
    return onFailed(this, std::forward<TFn>(handler));
}
 
template<typename TFn>
RestReply *RestReply::onFailed(QObject *scope, TFn &&handler)
{
    connect(this, &RestReply::failed,
            scope, __private::bindCallback(std::forward<TFn>(handler)),
            callbackType());
    return this;
}
 
template<typename TFn>
RestReply *RestReply::onCompleted(TFn &&handler)
{
    return onCompleted(this, std::forward<TFn>(handler));
}
 
template<typename TFn>
RestReply *RestReply::onCompleted(QObject *scope, TFn &&handler)
{
    connect(this, &RestReply::completed,
            scope, __private::bindCallback(std::forward<TFn>(handler)),
            callbackType());
    return this;
}
 
template<typename TFn>
RestReply *RestReply::onAllErrors(const std::function<void (QString, int, Error)> &handler, TFn &&failureTransformer)
{
    return onAllErrors(this, handler, std::forward<TFn>(failureTransformer));
}
 
template<typename TFn>
RestReply *RestReply::onAllErrors(QObject *scope, const std::function<void (QString, int, Error)> &handler, TFn &&failureTransformer)
{
    this->onFailed(scope, __private::bindCallback(handler, std::forward<TFn>(failureTransformer), Error::Failure));
    this->onError(scope, handler);
    return this;
}
 
}
 
#endif // QTRESTCLIENT_RESTREPLY_H