transmission/qt/RpcQueue.h

/*
 * 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;
};