simple.h

Go to the documentation of this file.

#ifndef QTRESTCLIENT_SIMPLEBASE_H
#define QTRESTCLIENT_SIMPLEBASE_H
 
#include "QtRestClient/qtrestclient_global.h"
#include "QtRestClient/genericrestreply.h"
#include "QtRestClient/restclass.h"
 
#include <functional>
 
#include <QtCore/qpointer.h>
#include <QtCore/qsharedpointer.h>
#include <QtCore/qscopedpointer.h>
 
namespace QtRestClient {
 
template <typename T, typename = void>
class Simple;
 
template<typename T>
class Simple<T*, std::enable_if_t<std::is_base_of_v<QObject, T>>> : public QObject
{
public:
    Simple(QObject *parent = nullptr);
 
    virtual QUrl extensionHref() const = 0;
    bool hasExtension() const;
    bool isExtended() const;
    T *currentExtended() const;
 
    template<typename ET = QObject*>
    GenericRestReply<T*, ET> *extend(RestClient *client);
 
    template<typename ET = QObject*>
    void extend(RestClient *client,
                std::function<void(T*, bool)> extensionHandler,
                const std::function<void(QString, int, RestReply::Error)> &errorHandler = {},
                std::function<QString(ET, int)> failureTransformer = {});
    template<typename ET = QObject*>
    void extend(RestClient *client,
                QObject *scope,
                std::function<void(T*, bool)> extensionHandler,
                const std::function<void(QString, int, RestReply::Error)> &errorHandler = {},
                std::function<QString(ET, int)> failureTransformer = {});
 
private:
    QSharedPointer<QPointer<T>> _ext;
    inline QPointer<T> &ext();
    inline const QPointer<T> &ext() const;
};
 
template<typename T>
class Simple<T, std::enable_if_t<std::is_void_v<typename T::QtGadgetHelper>>>
{
public:
    Simple();
    inline virtual ~Simple() = default;
 
    virtual QUrl extensionHref() const = 0;
    bool hasExtension() const;
    bool isExtended() const;
    T currentExtended() const;
 
    template<typename ET = QObject*>
    GenericRestReply<T, ET> *extend(RestClient *client);
 
    template<typename ET = QObject*>
    void extend(RestClient *client,
                std::function<void(T, bool)> extensionHandler,
                const std::function<void(QString, int, RestReply::Error)> &errorHandler = {},
                std::function<QString(ET, int)> failureTransformer = {});
    template<typename ET = QObject*>
    void extend(RestClient *client,
                QObject *scope,
                std::function<void(T, bool)> extensionHandler,
                const std::function<void(QString, int, RestReply::Error)> &errorHandler = {},
                std::function<QString(ET, int)> failureTransformer = {});
 
private:
    QSharedPointer<QScopedPointer<T>> _ext;
    inline QScopedPointer<T> &ext();
    inline const QScopedPointer<T> &ext() const;
};
 
}
 
#define QTRESTCLIENT_EXT_HREF_PROP(x) \
    inline QUrl extensionHref() const override { \
        return property(#x).toUrl();\
    }
 
// ------------- Generic Implementation object -------------
 
namespace QtRestClient {
 
template<typename T>
Simple<T*, std::enable_if_t<std::is_base_of_v<QObject, T>>>::Simple(QObject *parent) :
    QObject{parent},
    _ext{new QPointer<T>{}}
{}
 
template<typename T>
bool Simple<T*, std::enable_if_t<std::is_base_of_v<QObject, T>>>::hasExtension() const
{
    return extensionHref().isValid();
}
 
template<typename T>
bool Simple<T*, std::enable_if_t<std::is_base_of_v<QObject, T>>>::isExtended() const
{
    return ext();
}
 
template<typename T>
T *Simple<T*, std::enable_if_t<std::is_base_of_v<QObject, T>>>::currentExtended() const
{
    return ext();
}
 
template<typename T>
template<typename ET>
GenericRestReply<T*, ET> *Simple<T*, std::enable_if_t<std::is_base_of_v<QObject, T>>>::extend(RestClient *client)
{
    if (hasExtension()) {
        QWeakPointer<QPointer<T>> extRef = _ext;
        return client->rootClass()->get<T*, ET>(extensionHref())
            ->onSucceeded([extRef](int, T *data) {
                if (const auto ext = extRef.toStrongRef(); ext)
                    *ext = data;
            });
    } else
        return nullptr;
}
 
template<typename T>
template<typename ET>
void Simple<T*, std::enable_if_t<std::is_base_of_v<QObject, T>>>::extend(RestClient *client, std::function<void (T *, bool)> extensionHandler, const std::function<void (QString, int, RestReply::Error)> &errorHandler, std::function<QString (ET, int)> failureTransformer)
{
    extend(client,
           const_cast<Simple<T*, std::enable_if_t<std::is_base_of_v<QObject, T>>>*>(this),
           std::move(extensionHandler),
           errorHandler,
           std::move(failureTransformer));
}
 
template<typename T>
template<typename ET>
void Simple<T*, std::enable_if_t<std::is_base_of_v<QObject, T>>>::extend(RestClient *client, QObject *scope, std::function<void (T *, bool)> extensionHandler, const std::function<void (QString, int, RestReply::Error)> &errorHandler, std::function<QString (ET, int)> failureTransformer)
{
    if (ext())
        extensionHandler(ext(), false);
    else if(hasExtension()) {
        QWeakPointer<QPointer<T>> extRef = _ext;
        client->rootClass()->get<T*, ET>(extensionHref())
            ->onSucceeded(scope, [extRef, xEH = std::move(extensionHandler)](int, T *data){
                if (const auto ext = extRef.toStrongRef(); ext)
                    *ext = data;
                xEH(data, true);
            })
            ->onAllErrors(scope, errorHandler, std::move(failureTransformer));
    }
}
 
template<typename T>
QPointer<T> &QtRestClient::Simple<T*, std::enable_if_t<std::is_base_of_v<QObject, T>>>::ext()
{
    return *_ext;
}
 
template<typename T>
const QPointer<T> &QtRestClient::Simple<T*, std::enable_if_t<std::is_base_of_v<QObject, T>>>::ext() const
{
    return *_ext;
}
 
// ------------- Generic Implementation gadget -------------
 
template<typename T>
Simple<T, std::enable_if_t<std::is_void_v<typename T::QtGadgetHelper>>>::Simple() :
    _ext{new QScopedPointer<T>{nullptr}}
{}
 
template<typename T>
bool Simple<T, std::enable_if_t<std::is_void_v<typename T::QtGadgetHelper>>>::hasExtension() const
{
    return extensionHref().isValid();
}
 
template<typename T>
bool Simple<T, std::enable_if_t<std::is_void_v<typename T::QtGadgetHelper>>>::isExtended() const
{
    return ext();
}
 
template<typename T>
T Simple<T, std::enable_if_t<std::is_void_v<typename T::QtGadgetHelper>>>::currentExtended() const
{
    if (ext())
        return *(ext().data());
    else
        return {};
}
 
template<typename T>
template<typename ET>
GenericRestReply<T, ET> *Simple<T, std::enable_if_t<std::is_void_v<typename T::QtGadgetHelper>>>::extend(RestClient *client)
{
    if (hasExtension()) {
        QWeakPointer<QScopedPointer<T>> extRef = _ext;
        return client->rootClass()->get<T, ET>(extensionHref())
            ->onSucceeded([extRef](int, T data){
                if (const auto ext = extRef.toStrongRef(); ext)
                    ext.data()->reset(new T{data});
            });
    } else
        return nullptr;
}
 
template<typename T>
template<typename ET>
void Simple<T, std::enable_if_t<std::is_void_v<typename T::QtGadgetHelper>>>::extend(RestClient *client, std::function<void (T, bool)> extensionHandler, const std::function<void (QString, int, RestReply::Error)> &errorHandler, std::function<QString (ET, int)> failureTransformer)
{
    if (ext())
        extensionHandler(*(ext().data()), false);
    else if (hasExtension()) {
        QWeakPointer<QScopedPointer<T>> extRef = _ext;
        client->rootClass()->get<T, ET>(extensionHref())
            ->onSucceeded([extRef, xEH = std::move(extensionHandler)](int, T data){
                if (const auto ext = extRef.toStrongRef(); ext)
                    ext.data()->reset(new T{data});
                xEH(data, true);
            })
            ->onAllErrors(errorHandler, std::move(failureTransformer));
    }
}
 
template<typename T>
template<typename ET>
void Simple<T, std::enable_if_t<std::is_void_v<typename T::QtGadgetHelper>>>::extend(RestClient *client, QObject *scope, std::function<void (T, bool)> extensionHandler, const std::function<void (QString, int, RestReply::Error)> &errorHandler, std::function<QString (ET, int)> failureTransformer)
{
    if (ext())
        extensionHandler(*(ext().data()), false);
    else if (hasExtension()) {
        QWeakPointer<QScopedPointer<T>> extRef = _ext;
        client->rootClass()->get<T, ET>(extensionHref())
            ->onSucceeded(scope, [extRef, xEH = std::move(extensionHandler)](int, T data){
                if (const auto ext = extRef.toStrongRef(); ext)
                    ext.data()->reset(new T{data});
                xEH(data, true);
            })
            ->onAllErrors(scope, errorHandler, std::move(failureTransformer));
    }
}
 
template<typename T>
QScopedPointer<T> &QtRestClient::Simple<T, std::enable_if_t<std::is_void_v<typename T::QtGadgetHelper>>>::ext()
{
    return *_ext;
}
 
template<typename T>
const QScopedPointer<T> &QtRestClient::Simple<T, std::enable_if_t<std::is_void_v<typename T::QtGadgetHelper>>>::ext() const
{
    return *_ext;
}
 
}
 
#endif // QTRESTCLIENT_SIMPLEBASE_H