122 lines
4.3 KiB
C++
122 lines
4.3 KiB
C++
/*
|
|
* This file Copyright (C) 2016 Mnemosyne LLC
|
|
*
|
|
* It may be used under the GNU GPL versions 2 or 3
|
|
* or any future license endorsed by Mnemosyne LLC.
|
|
*
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <functional>
|
|
#include <type_traits>
|
|
|
|
#include <QFutureInterface>
|
|
#include <QFutureWatcher>
|
|
#include <QObject>
|
|
#include <QPair>
|
|
#include <QQueue>
|
|
|
|
#include "RpcClient.h"
|
|
|
|
class RpcQueue: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
explicit RpcQueue (QObject * parent = nullptr);
|
|
|
|
void setTolerateErrors (bool tolerateErrors = true) { myTolerateErrors = tolerateErrors; }
|
|
|
|
template <typename Func>
|
|
void add (Func func)
|
|
{
|
|
myQueue.enqueue (qMakePair (normalizeFunc (func),
|
|
ErrorHandlerFunction ()));
|
|
}
|
|
|
|
template <typename Func, typename ErrorHandler>
|
|
void add (Func func, ErrorHandler errorHandler)
|
|
{
|
|
myQueue.enqueue (qMakePair (normalizeFunc (func),
|
|
normalizeErrorHandler (errorHandler)));
|
|
}
|
|
|
|
RpcResponseFuture future ();
|
|
|
|
// The first function in queue is ran synchronously
|
|
// (hence it may be e. g. a lambda capturing local variables by reference).
|
|
void run ();
|
|
|
|
private:
|
|
// Internally queued function. Takes the last response future, makes a
|
|
// request and returns a new response future.
|
|
typedef std::function<RpcResponseFuture (const RpcResponseFuture&)> QueuedFunction;
|
|
|
|
// Internally stored error handler function. Takes the last response future and returns nothing.
|
|
typedef std::function<void (const RpcResponseFuture&)> ErrorHandlerFunction;
|
|
|
|
private slots:
|
|
void stepFinished ();
|
|
|
|
private:
|
|
void runNext (const RpcResponseFuture& response);
|
|
|
|
// These overloads convert various forms of input closures to what we store internally.
|
|
|
|
// normal closure, takes response and returns new future
|
|
template <typename Func,
|
|
typename std::enable_if<std::is_same<typename std::result_of<Func (const RpcResponse&)>::type, RpcResponseFuture>::value>::type * = nullptr>
|
|
QueuedFunction normalizeFunc (const Func& func)
|
|
{
|
|
return [func] (const RpcResponseFuture& r) { return func (r.result ()); };
|
|
}
|
|
|
|
// closure without argument (first step), takes nothing and returns new future
|
|
template <typename Func,
|
|
typename std::enable_if<std::is_same<typename std::result_of<Func ()>::type, RpcResponseFuture>::value>::type * = nullptr>
|
|
QueuedFunction normalizeFunc (const Func& func)
|
|
{
|
|
return [func] (const RpcResponseFuture&) { return func (); };
|
|
}
|
|
|
|
// closure without return value ("auxiliary"), takes response and returns nothing -- internally we reuse the last future
|
|
template <typename Func,
|
|
typename std::enable_if<std::is_same<typename std::result_of<Func (const RpcResponse&)>::type, void>::value>::type * = nullptr>
|
|
QueuedFunction normalizeFunc (const Func& func)
|
|
{
|
|
return [func] (const RpcResponseFuture& r) { func (r.result ()); return r; };
|
|
}
|
|
|
|
// closure without argument and return value, takes nothing and returns nothing -- next function will also get nothing
|
|
template <typename Func,
|
|
typename std::enable_if<std::is_same<typename std::result_of<Func ()>::type, void>::value>::type * = nullptr>
|
|
QueuedFunction normalizeFunc (const Func& func)
|
|
{
|
|
return [func] (const RpcResponseFuture& r) { func (); return r; };
|
|
}
|
|
|
|
// normal error handler, takes last response
|
|
template <typename Func,
|
|
typename std::enable_if<std::is_same<typename std::result_of<Func (const RpcResponse&)>::type, void>::value>::type * = nullptr>
|
|
ErrorHandlerFunction normalizeErrorHandler (const Func& func)
|
|
{
|
|
return [func] (const RpcResponseFuture& r) { func (r.result ()); };
|
|
}
|
|
|
|
// error handler without an argument, takes nothing
|
|
template <typename Func,
|
|
typename std::enable_if<std::is_same<typename std::result_of<Func ()>::type, void>::value>::type * = nullptr>
|
|
ErrorHandlerFunction normalizeErrorHandler (const Func& func)
|
|
{
|
|
return [func] (const RpcResponseFuture& r) { func (); };
|
|
}
|
|
|
|
private:
|
|
bool myTolerateErrors;
|
|
QFutureInterface<RpcResponse> myPromise;
|
|
QQueue<QPair<QueuedFunction, ErrorHandlerFunction>> myQueue;
|
|
ErrorHandlerFunction myNextErrorHandler;
|
|
QFutureWatcher<RpcResponse> myFutureWatcher;
|
|
};
|