restclient.h

#ifndef QTRESTCLIENT_RESTCLIENT_H
#define QTRESTCLIENT_RESTCLIENT_H
 
#include "QtRestClient/qtrestclient_global.h"
#include "QtRestClient/requestbuilder.h"
 
#include <QtCore/qobject.h>
#include <QtCore/qurl.h>
#include <QtCore/qurlquery.h>
#include <QtCore/qversionnumber.h>
#ifdef QT_RESTCLIENT_USE_ASYNC
#include <QtCore/qthreadpool.h>
#endif
 
#include <QtNetwork/qnetworkrequest.h>
 
#ifndef Q_RESTCLIENT_NO_JSON_SERIALIZER
namespace QtJsonSerializer {
class SerializerBase;
}
#endif
 
namespace QtRestClient {
 
class RestClass;
class IPagingFactory;
 
class RestClientPrivate;
class Q_RESTCLIENT_EXPORT RestClient : public QObject
{
    Q_OBJECT
    friend class RestClientPrivate;
 
    Q_PROPERTY(DataMode dataMode READ dataMode WRITE setDataMode NOTIFY dataModeChanged)
    Q_PROPERTY(QUrl baseUrl READ baseUrl WRITE setBaseUrl NOTIFY baseUrlChanged)
    Q_PROPERTY(QVersionNumber apiVersion READ apiVersion WRITE setApiVersion NOTIFY apiVersionChanged)
    Q_PROPERTY(HeaderHash globalHeaders READ globalHeaders WRITE setGlobalHeaders NOTIFY globalHeadersChanged)
    Q_PROPERTY(QUrlQuery globalParameters READ globalParameters WRITE setGlobalParameters NOTIFY globalParametersChanged)
    Q_PROPERTY(QHash<QNetworkRequest::Attribute, QVariant> requestAttributes READ requestAttributes WRITE setRequestAttributes NOTIFY requestAttributesChanged)
    Q_PROPERTY(bool threaded READ isThreaded WRITE setThreaded NOTIFY threadedChanged)
 
#ifndef QT_NO_SSL
    Q_PROPERTY(QSslConfiguration sslConfiguration READ sslConfiguration WRITE setSslConfiguration NOTIFY sslConfigurationChanged)
#endif
 
#ifdef QT_RESTCLIENT_USE_ASYNC
    Q_PROPERTY(QThreadPool* asyncPool READ asyncPool WRITE setAsyncPool NOTIFY asyncPoolChanged)
#endif
 
public:
    enum class DataMode {
        Cbor,  
        Json  
    };
    Q_ENUM(DataMode)
 
    
    explicit RestClient(QObject *parent = nullptr);
    explicit RestClient(DataMode dataMode, QObject *parent = nullptr);
#ifndef Q_RESTCLIENT_NO_JSON_SERIALIZER
    explicit RestClient(QtJsonSerializer::SerializerBase *serializer, QObject *parent = nullptr);
#endif
 
    RestClass *createClass(const QString &path, QObject *parent = nullptr);
    RestClass *rootClass() const;
 
    QNetworkAccessManager *manager() const;
#ifndef Q_RESTCLIENT_NO_JSON_SERIALIZER
    QtJsonSerializer::SerializerBase *serializer() const;
#endif
    IPagingFactory *pagingFactory() const;
 
    DataMode dataMode() const;
    QUrl baseUrl() const;
    QVersionNumber apiVersion() const;
    HeaderHash globalHeaders() const;
    QUrlQuery globalParameters() const;
    QHash<QNetworkRequest::Attribute, QVariant> requestAttributes() const;
    bool isThreaded() const;
#ifndef QT_NO_SSL
    QSslConfiguration sslConfiguration() const;
#endif
#ifdef QT_RESTCLIENT_USE_ASYNC
    QThreadPool* asyncPool() const;
#endif
 
    virtual RequestBuilder builder() const;
 
public Q_SLOTS:
    void setManager(QNetworkAccessManager *manager);
#ifndef Q_RESTCLIENT_NO_JSON_SERIALIZER
    void setSerializer(QtJsonSerializer::SerializerBase *serializer);
#endif
 
    void setPagingFactory(IPagingFactory *factory);
 
    void setDataMode(DataMode dataMode);
    void setBaseUrl(QUrl baseUrl);
    void setApiVersion(QVersionNumber apiVersion);
    void setGlobalHeaders(HeaderHash globalHeaders);
    void setGlobalParameters(QUrlQuery globalParameters);
    void setRequestAttributes(QHash<QNetworkRequest::Attribute, QVariant> requestAttributes);
    void setModernAttributes();
    void setThreaded(bool threaded);
#ifndef QT_NO_SSL
    void setSslConfiguration(QSslConfiguration sslConfiguration);
#endif
#ifdef QT_RESTCLIENT_USE_ASYNC
    void setAsyncPool(QThreadPool* asyncPool);
#endif
 
    void addGlobalHeader(const QByteArray &name, const QByteArray &value);
    void removeGlobalHeader(const QByteArray &name);
 
    void addGlobalParameter(const QString &name, const QString &value);
    void removeGlobalParameter(const QString &name);
 
    void addRequestAttribute(QNetworkRequest::Attribute attribute, const QVariant &value);
    void removeRequestAttribute(QNetworkRequest::Attribute attribute);
 
Q_SIGNALS:
    void dataModeChanged(DataMode dataMode, QPrivateSignal);
    void baseUrlChanged(QUrl baseUrl, QPrivateSignal);
    void apiVersionChanged(QVersionNumber apiVersion, QPrivateSignal);
    void globalHeadersChanged(HeaderHash globalHeaders, QPrivateSignal);
    void globalParametersChanged(QUrlQuery globalParameters, QPrivateSignal);
    void requestAttributesChanged(QHash<QNetworkRequest::Attribute, QVariant> requestAttributes, QPrivateSignal);
    void threadedChanged(bool threaded, QPrivateSignal);
#ifndef QT_NO_SSL
    void sslConfigurationChanged(QSslConfiguration sslConfiguration, QPrivateSignal);
#endif
#ifdef QT_RESTCLIENT_USE_ASYNC
    void asyncPoolChanged(QThreadPool* asyncPool, QPrivateSignal);
#endif
 
protected:
    RestClient(RestClientPrivate &dd, QObject *parent = nullptr);
    void setupNam();
 
private:
    Q_DECLARE_PRIVATE(RestClient)
};
 
}
 
#endif // QTRESTCLIENT_RESTCLIENT_H