transmission/qt/RpcQueue.h

154 lines
4.5 KiB
C
Raw Normal View History

/*
* 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 <cstdint>
#include <functional>
#include <type_traits>
#include <QFutureInterface>
#include <QFutureWatcher>
#include <QObject>
#include <QPair>
#include <QQueue>
#include "Macros.h"
#include "RpcClient.h"
class RpcQueue : public QObject
{
Q_OBJECT
TR_DISABLE_COPY_MOVE(RpcQueue)
public:
explicit RpcQueue(QObject* parent = nullptr);
void setTolerateErrors(bool tolerate_errors = true)
{
tolerate_errors_ = tolerate_errors;
}
template<typename Func>
void add(Func func)
{
queue_.enqueue(qMakePair(normalizeFunc(func), ErrorHandlerFunction()));
}
template<typename Func, typename ErrorHandler>
void add(Func func, ErrorHandler error_handler)
{
queue_.enqueue(qMakePair(normalizeFunc(func), normalizeErrorHandler(error_handler)));
}
// The first function in queue is ran synchronously
// (hence it may be e. g. a lambda capturing local variables by reference).
void run();
using Tag = uint64_t;
Tag tag() const
{
return tag_;
}
private:
// Internally queued function. Takes the last response future, makes a
// request and returns a new response future.
using QueuedFunction = std::function<RpcResponseFuture(RpcResponseFuture const&)>;
// Internally stored error handler function. Takes the last response future and returns nothing.
using ErrorHandlerFunction = std::function<void(RpcResponseFuture const&)>;
void runNext(RpcResponseFuture const& 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_v<typename std::invoke_result_t<Func, RpcResponse const&>, RpcResponseFuture>>::type* = nullptr>
QueuedFunction normalizeFunc(Func const& func) const
{
return [func](RpcResponseFuture const& 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_v<typename std::invoke_result_t<Func>, RpcResponseFuture>>::type* = nullptr>
QueuedFunction normalizeFunc(Func const& func) const
{
return [func](RpcResponseFuture const&)
{
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_v<typename std::invoke_result_t<Func, RpcResponse const&>, void>>::type* = nullptr>
QueuedFunction normalizeFunc(Func const& func) const
{
return [func](RpcResponseFuture const& 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_v<typename std::invoke_result_t<Func>, void>>::type* = nullptr>
QueuedFunction normalizeFunc(Func const& func) const
{
return [func](RpcResponseFuture const& r)
{
func();
return r;
};
}
// normal error handler, takes last response
template<
typename Func,
typename std::enable_if<std::is_same_v<typename std::invoke_result_t<Func, RpcResponse const&>, void>>::type* = nullptr>
ErrorHandlerFunction normalizeErrorHandler(Func const& func) const
{
return [func](RpcResponseFuture const& r)
{
func(r.result());
};
}
// error handler without an argument, takes nothing
template<typename Func, typename std::enable_if<std::is_same_v<typename std::invoke_result_t<Func>, void>>::type* = nullptr>
ErrorHandlerFunction normalizeErrorHandler(Func const& func) const
{
fix: gcc warnings in libtransmission/ and utils/ (#843) * fix: __attribute__(__printf__) warnings * fix: implicit fallthrough warning * fixup! fix: implicit fallthrough warning * fix: disable warnings for 3rd party code Since we want to leave upstream code as-is * fixup! fix: disable warnings for 3rd party code * fixup! fix: disable warnings for 3rd party code * silence spurious alignment warning Xrefs Discussion: https://stackoverflow.com/a/35554349 Macro inspiration: https://pagure.io/SSSD/sssd/blob/90ac46f71068d131391492360a8553bdd005b5a7/f/src/util/util_safealign.h#_35 * fixup! fix: disable warnings for 3rd party code * fixup! fix: implicit fallthrough warning * make uncrustify happy * remove uncrustify-test.sh that's probably off-topic for this PR * fixup! fix: __attribute__(__printf__) warnings * Update libtransmission/CMakeLists.txt Co-Authored-By: ckerr <ckerr@github.com> * fixup! silence spurious alignment warning * use -w for DISABLE_WARNINGS in Clang * refactor: fix libtransmission deprecation warnings * fix: pthread_create's start_routine's return value This was defined as `void` on non-Windows but should have been `void*` * chore: uncrustify * fix: add DISABLE_WARNINGS option for SunPro Studio * fix "unused in lambda capture" warnings by clang++ * fix 'increases required alignment' warning Caused from storing int16_t's in a char array. * fix net.c 'increases required alignment' warning The code passes in a `struct sockaddr_storage*` which is a padded struct large enough for the necessary alignment. Unfortunately it was recast as a `struct sockaddr*` which has less padding and a smaller alignment. The warning occrred because of these differing alignments. * make building quieter so warnings are more visible * fixup! fix 'increases required alignment' warning * Fix -Wcast-function-type warnings in GTK+ app code https://gitlab.gnome.org/GNOME/gnome-terminal/issues/96 talks about both the issue and its solution. GCC 8's -Wcast-function-type, enabled by -Wextra, is problematic in glib applications because it's idiomatic there to recast function signatures, e.g. `g_slist_free(list, (GFunc)g_free, NULL);`. Disabling the warning with pragmas causes "unrecognized pragma" warnings on clang and older versions of gcc, and disabling the warning could miss actual bugs. GCC defines `void (*)(void)` as a special case that matches anything so we can silence warnings by double-casting through GCallback. In the previous example, the warning is silenced by changing the code to read `g_slist_free(list, (GFunc)(GCallback)g_free, NULL);`). * fixup! fix "unused in lambda capture" warnings by clang++ * fixup! fix "unused in lambda capture" warnings by clang++ * fix two more libtransmission compiler warnings * fix: in watchdir, use TR_ENABLE_ASSERTS not NDEBUG
2019-11-06 17:27:03 +00:00
return [func](RpcResponseFuture const&)
{
func();
};
}
Tag const tag_;
static Tag next_tag;
bool tolerate_errors_ = {};
QFutureInterface<RpcResponse> promise_;
QQueue<QPair<QueuedFunction, ErrorHandlerFunction>> queue_;
ErrorHandlerFunction next_error_handler_;
QFutureWatcher<RpcResponse> future_watcher_;
private slots:
void stepFinished();
};