restreplyawaitable.h

#ifndef RESTREPLYAWAITABLE_H
#define RESTREPLYAWAITABLE_H
 
#include "QtRestClient/qtrestclient_global.h"
#include "QtRestClient/restreply.h"
 
#ifndef Q_RESTCLIENT_NO_JSON_SERIALIZER
#include "QtRestClient/genericrestreply.h"
#endif
 
#if defined(DOXYGEN_RUN) || (!defined(QT_NO_EXCEPTIONS) && QT_CONFIG(future))
#include <QtCore/QException>
namespace QtRestClient {
using ExceptionBase = QException;
}
#else
#include <exception>
namespace QtRestClient {
using ExceptionBase = std::exception;
}
#endif
 
namespace QtRestClient {
 
class Q_RESTCLIENT_EXPORT AwaitedException : public ExceptionBase
{
public:
    AwaitedException(int code, RestReply::Error type, QVariant data);
 
    int errorCode() const;
    RestReply::Error errorType() const;
    QVariant errorData() const;
 
    QVariantMap errorObject() const;
    QVariantList errorArray() const;
    QString errorString() const;
    QString errorString(const std::function<QString(QVariantMap, int)> &failureTransformer) const;
    QString errorString(const std::function<QString(QVariantList, int)> &failureTransformer) const;
 
    const char *what() const noexcept override;
 
    virtual Q_NORETURN void raise() const;
    virtual ExceptionBase *clone() const;
 
protected:
    const int _code;
    const RestReply::Error _type;
    const QVariant _data;
    mutable QByteArray _msg;
};
 
class RestReplyAwaitablePrivate;
class Q_RESTCLIENT_EXPORT RestReplyAwaitable
{
public:
    RestReplyAwaitable(RestReply *reply);
    RestReplyAwaitable(RestReplyAwaitable &&other) noexcept;
    RestReplyAwaitable &operator=(RestReplyAwaitable &&other) noexcept;
    ~RestReplyAwaitable();
 
    using type = RestReply::DataType;
    using exceptionType = AwaitedException;
    void prepare(const std::function<void()> &resume);
    type result();
 
private:
    QScopedPointer<RestReplyAwaitablePrivate> d;
};
 
 
 
#ifndef Q_RESTCLIENT_NO_JSON_SERIALIZER
template <typename ErrorClassType = QObject*>
class GenericAwaitedException : public AwaitedException
{
public:
    GenericAwaitedException(int code, const ErrorClassType &data);
    GenericAwaitedException(int code, RestReply::Error type, const QString &data);
 
    ErrorClassType genericError() const;
    using AwaitedException::errorString;
    QString errorString(const std::function<QString(ErrorClassType, int)> &failureTransformer) const;
 
    Q_NORETURN void raise() const override;
    ExceptionBase *clone() const override;
 
private:
    using AwaitedException::errorObject;
    using AwaitedException::errorArray;
};
 
template <typename DataClassType, typename ErrorClassType = QObject*>
class GenericRestReplyAwaitable
{
public:
    GenericRestReplyAwaitable(GenericRestReply<DataClassType, ErrorClassType> *reply);
    GenericRestReplyAwaitable(GenericRestReplyAwaitable<DataClassType, ErrorClassType> &&other) noexcept;
    GenericRestReplyAwaitable &operator=(GenericRestReplyAwaitable<DataClassType, ErrorClassType> &&other) noexcept;
 
    using type = DataClassType;
    using exceptionType = GenericAwaitedException<ErrorClassType>;
    void prepare(const std::function<void()> &resume);
    type result();
 
private:
    QPointer<GenericRestReply<DataClassType, ErrorClassType>> reply;
    DataClassType successResult;
    QScopedPointer<exceptionType> errorResult;
};
 
template <typename ErrorClassType>
class GenericRestReplyAwaitable<void, ErrorClassType>
{
public:
    GenericRestReplyAwaitable(GenericRestReply<void, ErrorClassType> *reply);
    GenericRestReplyAwaitable(GenericRestReplyAwaitable<void, ErrorClassType> &&other) noexcept;
    GenericRestReplyAwaitable &operator=(GenericRestReplyAwaitable<void, ErrorClassType> &&other) noexcept ;
 
    using type = void;
    using exceptionType = GenericAwaitedException<ErrorClassType>;
    void prepare(const std::function<void()> &resume);
    type result();
 
private:
    QPointer<GenericRestReply<void, ErrorClassType>> reply;
    QScopedPointer<exceptionType> errorResult;
};
#endif
 
// ------------- Generic Implementation -------------
 
#ifndef Q_RESTCLIENT_NO_JSON_SERIALIZER
template<typename DataClassType, typename ErrorClassType>
GenericRestReplyAwaitable<DataClassType, ErrorClassType>::GenericRestReplyAwaitable(GenericRestReply<DataClassType, ErrorClassType> *reply) :
    reply{reply}
{}
 
template<typename DataClassType, typename ErrorClassType>
GenericRestReplyAwaitable<DataClassType, ErrorClassType>::GenericRestReplyAwaitable(GenericRestReplyAwaitable<DataClassType, ErrorClassType> &&other) noexcept :
    reply{other.reply},
    successResult{std::move(other.successResult)}
{
    errorResult.swap(other.errorResult);
}
 
template<typename DataClassType, typename ErrorClassType>
GenericRestReplyAwaitable<DataClassType, ErrorClassType> &GenericRestReplyAwaitable<DataClassType, ErrorClassType>::operator=(GenericRestReplyAwaitable<DataClassType, ErrorClassType> &&other) noexcept
{
    reply = other.reply;
    successResult = std::move(other.successResult);
    errorResult.swap(other.errorResult);
    return *this;
}
 
template<typename DataClassType, typename ErrorClassType>
void GenericRestReplyAwaitable<DataClassType, ErrorClassType>::prepare(const std::function<void ()> &resume)
{
    reply->onSucceeded([this, resume](int, DataClassType data) {
        errorResult.reset();
        successResult = std::move(data);
        resume();
    });
    reply->onFailed([this, resume](int code, ErrorClassType data) {
        errorResult.reset(new exceptionType{code, std::move(data)});
        resume();
    });
    reply->onSerializeException([this, resume](const QtJsonSerializer::Exception &data) {
        errorResult.reset(new exceptionType{0, RestReply::Error::Deserialization, QString::fromUtf8(data.what())});
        resume();
    });
    reply->onError([this, resume](const QString &message, int code, RestReply::Error type) {
        errorResult.reset(new exceptionType{code, type, message});
        resume();
    });
}
 
template<typename DataClassType, typename ErrorClassType>
typename GenericRestReplyAwaitable<DataClassType, ErrorClassType>::type GenericRestReplyAwaitable<DataClassType, ErrorClassType>::result()
{
    if (errorResult) {
        errorResult->raise();
        Q_UNREACHABLE();
    } else
        return successResult;
}
 
 
 
template<typename ErrorClassType>
GenericRestReplyAwaitable<void, ErrorClassType>::GenericRestReplyAwaitable(GenericRestReply<void, ErrorClassType> *reply) :
    reply{reply}
{}
 
template<typename ErrorClassType>
GenericRestReplyAwaitable<void, ErrorClassType>::GenericRestReplyAwaitable(GenericRestReplyAwaitable<void, ErrorClassType> &&other) noexcept :
    reply{other.reply}
{
    errorResult.swap(other.errorResult);
}
 
template<typename ErrorClassType>
GenericRestReplyAwaitable<void, ErrorClassType> &GenericRestReplyAwaitable<void, ErrorClassType>::operator=(GenericRestReplyAwaitable<void, ErrorClassType> &&other) noexcept
{
    reply = other.reply;
    errorResult.swap(other.errorResult);
    return *this;
}
 
template<typename ErrorClassType>
void GenericRestReplyAwaitable<void, ErrorClassType>::prepare(const std::function<void ()> &resume)
{
    reply->onSucceeded([this, resume](int) {
        errorResult.reset();
        resume();
    });
    reply->onFailed([this, resume](int code, ErrorClassType data) {
        errorResult.reset(new exceptionType{code, std::move(data)});
        resume();
    });
    reply->onSerializeException([this, resume](const QtJsonSerializer::Exception &data) {
        errorResult.reset(new exceptionType{0, RestReply::Error::Deserialization, QString::fromUtf8(data.what())});
        resume();
    });
    reply->onError([this, resume](const QString &message, int code, RestReply::Error type) {
        errorResult.reset(new exceptionType{code, type, message});
        resume();
    });
}
 
template<typename ErrorClassType>
typename GenericRestReplyAwaitable<void, ErrorClassType>::type GenericRestReplyAwaitable<void, ErrorClassType>::result()
{
    if (errorResult) {
        errorResult->raise();
        Q_UNREACHABLE();
    }
}
 
 
 
template<typename ErrorClassType>
GenericAwaitedException<ErrorClassType>::GenericAwaitedException(int code, const ErrorClassType &data) :
    AwaitedException{code, RestReply::Error::Failure, QVariant::fromValue<ErrorClassType>(data)}
{}
 
template<typename ErrorClassType>
GenericAwaitedException<ErrorClassType>::GenericAwaitedException(int code, RestReply::Error type, const QString &data) :
    AwaitedException{code, type, data}
{}
 
template<typename ErrorClassType>
ErrorClassType GenericAwaitedException<ErrorClassType>::genericError() const
{
    return _data.template value<ErrorClassType>();
}
 
template<typename ErrorClassType>
QString GenericAwaitedException<ErrorClassType>::errorString(const std::function<QString (ErrorClassType, int)> &failureTransformer) const
{
    if(_type == RestReply::Error::Failure)
        return failureTransformer(genericError(), _code);
    else
        return errorString();
}
 
template<typename ErrorClassType>
void GenericAwaitedException<ErrorClassType>::raise() const
{
    throw *this;
}
 
template<typename ErrorClassType>
ExceptionBase *GenericAwaitedException<ErrorClassType>::clone() const
{
    return new GenericAwaitedException<ErrorClassType>{*this};
}
 
// await method implementations
 
template<typename DataClassType, typename ErrorClassType>
GenericRestReplyAwaitable<DataClassType, ErrorClassType> GenericRestReplyBase<DataClassType, ErrorClassType>::awaitable()
{
    return GenericRestReplyAwaitable<DataClassType, ErrorClassType>{static_cast<TInstance*>(this)};
}
#endif
 
}
 
#endif // RESTREPLYAWAITABLE_H