QtConcurrent::run: accept more then five function's arguments

[ChangeLog][Potentially Source-Incompatible Changes] QtConcurrent::run
has the following signatures: run(Function &&f, Args &&...args) and
run(QThreadPool *pool, Function &&f, Args &&...args). If f is a member
pointer, the first argument of args should be an object for which that
member is defined (or a reference, or a pointer to it). See the
documentation for more details.

Fixes: QTBUG-82383
Change-Id: I18f7fcfb2adbdd9f75b29c346bd3516304e32d31
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Reviewed-by: Sona Kurazyan <sona.kurazyan@qt.io>

9 files changed, 198 insertions, 3112 deletions

diff --git a/examples/vulkan/hellovulkancubes/renderer.cpp b/examples/vulkan/hellovulkancubes/renderer.cpp
index f104d79002..da493de739 100644
--- a/examples/vulkan/hellovulkancubes/renderer.cpp
+++ b/examples/vulkan/hellovulkancubes/renderer.cpp
@@ -136,7 +136,7 @@ void Renderer::initResources()
     if (!m_floorMaterial.fs.isValid())
         m_floorMaterial.fs.load(inst, dev, QStringLiteral(":/color_frag.spv"));
 
-    m_pipelinesFuture = QtConcurrent::run(this, &Renderer::createPipelines);
+    m_pipelinesFuture = QtConcurrent::run(&Renderer::createPipelines, this);
 }
 
 void Renderer::createPipelines()
@@ -879,7 +879,7 @@ void Renderer::startNextFrame()
     // finished.
     Q_ASSERT(!m_framePending);
     m_framePending = true;
-    QFuture<void> future = QtConcurrent::run(this, &Renderer::buildFrame);
+    QFuture<void> future = QtConcurrent::run(&Renderer::buildFrame, this);
     m_frameWatcher.setFuture(future);
 }
 
diff --git a/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp
index 5437822842..0b82766054 100644
--- a/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp
+++ b/src/concurrent/doc/snippets/code/src_concurrent_qtconcurrentrun.cpp
@@ -93,7 +93,7 @@ QString result = future.result();
 //! [4]
 // call 'QList<QByteArray>  QByteArray::split(char sep) const' in a separate thread
 QByteArray bytearray = "hello world";
-QFuture<QList<QByteArray> > future = QtConcurrent::run(bytearray, &QByteArray::split, ',');
+QFuture<QList<QByteArray> > future = QtConcurrent::run(&QByteArray::split, bytearray, ',');
 ...
 QList<QByteArray> result = future.result();
 //! [4]
@@ -101,16 +101,46 @@ QList<QByteArray> result = future.result();
 //! [5]
 // call 'void QImage::invertPixels(InvertMode mode)' in a separate thread
 QImage image = ...;
-QFuture<void> future = QtConcurrent::run(&image, &QImage::invertPixels, QImage::InvertRgba);
+QFuture<void> future = QtConcurrent::run(&QImage::invertPixels, &image, QImage::InvertRgba);
 ...
 future.waitForFinished();
 // At this point, the pixels in 'image' have been inverted
 //! [5]
 
-
 //! [6]
 QFuture<void> future = QtConcurrent::run([=]() {
     // Code in this block will run in another thread
 });
 ...
 //! [6]
+
+//! [7]
+static void addOne(int &n) { ++n; }
+...
+int n = 42;
+QtConcurrent::run(&addOne, std::ref(n)).waitForFinished(); // n == 43
+//! [7]
+
+//! [8]
+struct TestClass
+{
+    void operator()(int s1) { s = s1; }
+    int s = 42;
+};
+
+...
+
+TestClass o;
+
+// Modify original object
+QtConcurrent::run(std::ref(o), 15).waitForFinished(); // o.s == 15
+
+// Modify a copy of the original object
+QtConcurrent::run(o, 42).waitForFinished(); // o.s == 15
+
+// Use a temporary object
+QtConcurrent::run(TestClass(), 42).waitForFinished();
+
+// Ill-formed
+QtConcurrent::run(&o, 42).waitForFinished(); // compilation error
+//! [8]
diff --git a/src/concurrent/qtconcurrentrun.cpp b/src/concurrent/qtconcurrentrun.cpp
index d9867e1f1a..c5f2e113a2 100644
--- a/src/concurrent/qtconcurrentrun.cpp
+++ b/src/concurrent/qtconcurrentrun.cpp
@@ -112,6 +112,14 @@
     Calling a lambda function is done like this:
 
     \snippet code/src_concurrent_qtconcurrentrun.cpp 6
+
+    Calling a function modifies an object passed by reference is done like this:
+
+    \snippet code/src_concurrent_qtconcurrentrun.cpp 7
+
+    Using callable object is done like this:
+
+    \snippet code/src_concurrent_qtconcurrentrun.cpp 8
 */
 
 /*!
diff --git a/src/concurrent/qtconcurrentrun.h b/src/concurrent/qtconcurrentrun.h
index 22dae70460..15a207be33 100644
--- a/src/concurrent/qtconcurrentrun.h
+++ b/src/concurrent/qtconcurrentrun.h
@@ -37,7 +37,6 @@
 **
 ****************************************************************************/
 
-// Generated code, do not edit! Use generator at tools/qtconcurrent/generaterun/
 #ifndef QTCONCURRENT_RUN_H
 #define QTCONCURRENT_RUN_H
 
@@ -68,847 +67,20 @@ namespace QtConcurrent {
 
 namespace QtConcurrent {
 
-template <typename T>
-QFuture<T> run(T (*functionPointer)())
+template <class Function, class ...Args>
+[[nodiscard]]
+auto run(QThreadPool *pool, Function &&f, Args &&...args)
 {
-    return (new StoredFunctorCall0<T, T (*)()>(functionPointer))->start();
-}
-template <typename T, typename Param1, typename Arg1>
-QFuture<T> run(T (*functionPointer)(Param1), const Arg1 &arg1)
-{
-    return (new StoredFunctorCall1<T, T (*)(Param1), Arg1>(functionPointer, arg1))->start();
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(T (*functionPointer)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new StoredFunctorCall2<T, T (*)(Param1, Param2), Arg1, Arg2>(functionPointer, arg1, arg2))->start();
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(T (*functionPointer)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new StoredFunctorCall3<T, T (*)(Param1, Param2, Param3), Arg1, Arg2, Arg3>(functionPointer, arg1, arg2, arg3))->start();
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(T (*functionPointer)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new StoredFunctorCall4<T, T (*)(Param1, Param2, Param3, Param4), Arg1, Arg2, Arg3, Arg4>(functionPointer, arg1, arg2, arg3, arg4))->start();
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(T (*functionPointer)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new StoredFunctorCall5<T, T (*)(Param1, Param2, Param3, Param4, Param5), Arg1, Arg2, Arg3, Arg4, Arg5>(functionPointer, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-template <typename Functor>
-auto run(Functor functor) -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor())>>::type
-{
-    typedef decltype(functor()) result_type;
-    return (new StoredFunctorCall0<result_type, Functor>(functor))->start();
-}
-
-template <typename Functor, typename Arg1>
-auto run(Functor functor, const Arg1 &arg1)
-    -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor(arg1))>>::type
-{
-    typedef decltype(functor(arg1)) result_type;
-    return (new StoredFunctorCall1<result_type, Functor, Arg1>(functor, arg1))->start();
-}
-
-template <typename Functor, typename Arg1, typename Arg2>
-auto run(Functor functor, const Arg1 &arg1, const Arg2 &arg2)
-    -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor(arg1, arg2))>>::type
-{
-    typedef decltype(functor(arg1, arg2)) result_type;
-    return (new StoredFunctorCall2<result_type, Functor, Arg1, Arg2>(functor, arg1, arg2))->start();
-}
-
-template <typename Functor, typename Arg1, typename Arg2, typename Arg3>
-auto run(Functor functor, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-    -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor(arg1, arg2, arg3))>>::type
-{
-    typedef decltype(functor(arg1, arg2, arg3)) result_type;
-    return (new StoredFunctorCall3<result_type, Functor, Arg1, Arg2, Arg3>(functor, arg1, arg2, arg3))->start();
-}
-
-template <typename Functor, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-auto run(Functor functor, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-    -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor(arg1, arg2, arg3, arg4))>>::type
-{
-    typedef decltype(functor(arg1, arg2, arg3, arg4)) result_type;
-    return (new StoredFunctorCall4<result_type, Functor, Arg1, Arg2, Arg3, Arg4>(functor, arg1, arg2, arg3, arg4))->start();
-}
-
-template <typename Functor, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-auto run(Functor functor, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-    -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor(arg1, arg2, arg3, arg4, arg5))>>::type
-{
-    typedef decltype(functor(arg1, arg2, arg3, arg4, arg5)) result_type;
-    return (new StoredFunctorCall5<result_type, Functor, Arg1, Arg2, Arg3, Arg4, Arg5>(functor, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-template <typename FunctionObject>
-QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject)
-{
-    return (new StoredFunctorCall0<typename FunctionObject::result_type, FunctionObject>(functionObject))->start();
-}
-template <typename FunctionObject, typename Arg1>
-QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject, const Arg1 &arg1)
-{
-    return (new StoredFunctorCall1<typename FunctionObject::result_type, FunctionObject, Arg1>(functionObject, arg1))->start();
-}
-template <typename FunctionObject, typename Arg1, typename Arg2>
-QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new StoredFunctorCall2<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2>(functionObject, arg1, arg2))->start();
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3>
-QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new StoredFunctorCall3<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3>(functionObject, arg1, arg2, arg3))->start();
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new StoredFunctorCall4<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4>(functionObject, arg1, arg2, arg3, arg4))->start();
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new StoredFunctorCall5<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4, Arg5>(functionObject, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-template <typename FunctionObject>
-QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject)
-{
-    return (new typename SelectStoredFunctorPointerCall0<typename FunctionObject::result_type, FunctionObject>::type(functionObject))->start();
-}
-template <typename FunctionObject, typename Arg1>
-QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject, const Arg1 &arg1)
-{
-    return (new typename SelectStoredFunctorPointerCall1<typename FunctionObject::result_type, FunctionObject, Arg1>::type(functionObject, arg1))->start();
-}
-template <typename FunctionObject, typename Arg1, typename Arg2>
-QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredFunctorPointerCall2<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2>::type(functionObject, arg1, arg2))->start();
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3>
-QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredFunctorPointerCall3<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3>::type(functionObject, arg1, arg2, arg3))->start();
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredFunctorPointerCall4<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4>::type(functionObject, arg1, arg2, arg3, arg4))->start();
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredFunctorPointerCall5<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4, Arg5>::type(functionObject, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-template <typename T, typename Class>
-QFuture<T> run(const Class &object, T (Class::*fn)())
-{
-    return (new typename SelectStoredMemberFunctionCall0<T, Class>::type(fn, object))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1), const Arg1 &arg1)
-{
-    return (new typename SelectStoredMemberFunctionCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-template <typename T, typename Class>
-QFuture<T> run(const Class &object, T (Class::*fn)() const)
-{
-    return (new typename SelectStoredConstMemberFunctionCall0<T, Class>::type(fn, object))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1) const, const Arg1 &arg1)
-{
-    return (new typename SelectStoredConstMemberFunctionCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2) const, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredConstMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredConstMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredConstMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredConstMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-template <typename T, typename Class>
-QFuture<T> run(Class *object, T (Class::*fn)())
-{
-    return (new typename SelectStoredMemberFunctionPointerCall0<T, Class>::type(fn, object))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(Class *object, T (Class::*fn)(Param1), const Arg1 &arg1)
-{
-    return (new typename SelectStoredMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-template <typename T, typename Class>
-QFuture<T> run(const Class *object, T (Class::*fn)() const)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall0<T, Class>::type(fn, object))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(const Class *object, T (Class::*fn)(Param1) const, const Arg1 &arg1)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2) const, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2, Param3) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-// ...and the same with a QThreadPool *pool argument...
-// generate from the above by c'n'p and s/run(/run(QThreadPool *pool, / and s/start()/start(pool)/
-
-template <typename T>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)())
-{
-    return (new StoredFunctorCall0<T, T (*)()>(functionPointer))->start(pool);
-}
-template <typename T, typename Param1, typename Arg1>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)(Param1), const Arg1 &arg1)
-{
-    return (new StoredFunctorCall1<T, T (*)(Param1), Arg1>(functionPointer, arg1))->start(pool);
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new StoredFunctorCall2<T, T (*)(Param1, Param2), Arg1, Arg2>(functionPointer, arg1, arg2))->start(pool);
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new StoredFunctorCall3<T, T (*)(Param1, Param2, Param3), Arg1, Arg2, Arg3>(functionPointer, arg1, arg2, arg3))->start(pool);
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new StoredFunctorCall4<T, T (*)(Param1, Param2, Param3, Param4), Arg1, Arg2, Arg3, Arg4>(functionPointer, arg1, arg2, arg3, arg4))->start(pool);
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new StoredFunctorCall5<T, T (*)(Param1, Param2, Param3, Param4, Param5), Arg1, Arg2, Arg3, Arg4, Arg5>(functionPointer, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-template <typename Functor>
-auto run(QThreadPool *pool, Functor functor) -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor())>>::type
-{
-    typedef decltype(functor()) result_type;
-    return (new StoredFunctorCall0<result_type, Functor>(functor))->start(pool);
-}
-
-template <typename Functor, typename Arg1>
-auto run(QThreadPool *pool, Functor functor, const Arg1 &arg1)
-    -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor(arg1))>>::type
-{
-    typedef decltype(functor(arg1)) result_type;
-    return (new StoredFunctorCall1<result_type, Functor, Arg1>(functor, arg1))->start(pool);
-}
-
-template <typename Functor, typename Arg1, typename Arg2>
-auto run(QThreadPool *pool, Functor functor, const Arg1 &arg1, const Arg2 &arg2)
-    -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor(arg1, arg2))>>::type
-{
-    typedef decltype(functor(arg1, arg2)) result_type;
-    return (new StoredFunctorCall2<result_type, Functor, Arg1, Arg2>(functor, arg1, arg2))->start(pool);
+    return (new StoredFunctionCall<Function, Args...>(
+                std::forward<Function>(f), std::forward<Args>(args)...))->start(pool);
 }
 
-template <typename Functor, typename Arg1, typename Arg2, typename Arg3>
-auto run(QThreadPool *pool, Functor functor, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-    -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor(arg1, arg2, arg3))>>::type
-{
-    typedef decltype(functor(arg1, arg2, arg3)) result_type;
-    return (new StoredFunctorCall3<result_type, Functor, Arg1, Arg2, Arg3>(functor, arg1, arg2, arg3))->start(pool);
-}
-
-template <typename Functor, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-auto run(QThreadPool *pool, Functor functor, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-    -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor(arg1, arg2, arg3, arg4))>>::type
-{
-    typedef decltype(functor(arg1, arg2, arg3, arg4)) result_type;
-    return (new StoredFunctorCall4<result_type, Functor, Arg1, Arg2, Arg3, Arg4>(functor, arg1, arg2, arg3, arg4))->start(pool);
-}
-
-template <typename Functor, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-auto run(QThreadPool *pool, Functor functor, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-    -> typename std::enable_if<!QtPrivate::HasResultType<Functor>::Value, QFuture<decltype(functor(arg1, arg2, arg3, arg4, arg5))>>::type
-{
-    typedef decltype(functor(arg1, arg2, arg3, arg4, arg5)) result_type;
-    return (new StoredFunctorCall5<result_type, Functor, Arg1, Arg2, Arg3, Arg4, Arg5>(functor, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-template <typename FunctionObject>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject functionObject)
-{
-    return (new StoredFunctorCall0<typename FunctionObject::result_type, FunctionObject>(functionObject))->start(pool);
-}
-template <typename FunctionObject, typename Arg1>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject functionObject, const Arg1 &arg1)
-{
-    return (new StoredFunctorCall1<typename FunctionObject::result_type, FunctionObject, Arg1>(functionObject, arg1))->start(pool);
-}
-template <typename FunctionObject, typename Arg1, typename Arg2>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new StoredFunctorCall2<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2>(functionObject, arg1, arg2))->start(pool);
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new StoredFunctorCall3<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3>(functionObject, arg1, arg2, arg3))->start(pool);
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new StoredFunctorCall4<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4>(functionObject, arg1, arg2, arg3, arg4))->start(pool);
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new StoredFunctorCall5<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4, Arg5>(functionObject, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-template <typename FunctionObject>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject *functionObject)
-{
-    return (new typename SelectStoredFunctorPointerCall0<typename FunctionObject::result_type, FunctionObject>::type(functionObject))->start(pool);
-}
-template <typename FunctionObject, typename Arg1>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject *functionObject, const Arg1 &arg1)
-{
-    return (new typename SelectStoredFunctorPointerCall1<typename FunctionObject::result_type, FunctionObject, Arg1>::type(functionObject, arg1))->start(pool);
-}
-template <typename FunctionObject, typename Arg1, typename Arg2>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredFunctorPointerCall2<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2>::type(functionObject, arg1, arg2))->start(pool);
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredFunctorPointerCall3<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3>::type(functionObject, arg1, arg2, arg3))->start(pool);
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredFunctorPointerCall4<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4>::type(functionObject, arg1, arg2, arg3, arg4))->start(pool);
-}
-template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-QFuture<typename FunctionObject::result_type> run(QThreadPool *pool, FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredFunctorPointerCall5<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4, Arg5>::type(functionObject, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-template <typename T, typename Class>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)())
-{
-    return (new typename SelectStoredMemberFunctionCall0<T, Class>::type(fn, object))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1), const Arg1 &arg1)
-{
-    return (new typename SelectStoredMemberFunctionCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
+template <class Function, class ...Args>
+[[nodiscard]]
+auto run(Function &&f, Args &&...args)
 {
-    return (new typename SelectStoredMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start(pool);
+    return run(QThreadPool::globalInstance(), std::forward<Function>(f), std::forward<Args>(args)...);
 }
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-template <typename T, typename Class>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)() const)
-{
-    return (new typename SelectStoredConstMemberFunctionCall0<T, Class>::type(fn, object))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1) const, const Arg1 &arg1)
-{
-    return (new typename SelectStoredConstMemberFunctionCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2) const, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredConstMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredConstMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredConstMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredConstMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-template <typename T, typename Class>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)())
-{
-    return (new typename SelectStoredMemberFunctionPointerCall0<T, Class>::type(fn, object))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)(Param1), const Arg1 &arg1)
-{
-    return (new typename SelectStoredMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-template <typename T, typename Class>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)() const)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall0<T, Class>::type(fn, object))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)(Param1) const, const Arg1 &arg1)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)(Param1, Param2) const, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)(Param1, Param2, Param3) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredConstMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
-template <typename T>
-QFuture<T> run(T (*functionPointer)() noexcept)
-{
-    return (new StoredFunctorCall0<T, T (*)() noexcept>(functionPointer))->start();
-}
-template <typename T, typename Param1, typename Arg1>
-QFuture<T> run(T (*functionPointer)(Param1) noexcept, const Arg1 &arg1)
-{
-    return (new StoredFunctorCall1<T, T (*)(Param1) noexcept, Arg1>(functionPointer, arg1))->start();
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(T (*functionPointer)(Param1, Param2) noexcept, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new StoredFunctorCall2<T, T (*)(Param1, Param2) noexcept, Arg1, Arg2>(functionPointer, arg1, arg2))->start();
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(T (*functionPointer)(Param1, Param2, Param3) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new StoredFunctorCall3<T, T (*)(Param1, Param2, Param3) noexcept, Arg1, Arg2, Arg3>(functionPointer, arg1, arg2, arg3))->start();
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(T (*functionPointer)(Param1, Param2, Param3, Param4) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new StoredFunctorCall4<T, T (*)(Param1, Param2, Param3, Param4) noexcept, Arg1, Arg2, Arg3, Arg4>(functionPointer, arg1, arg2, arg3, arg4))->start();
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(T (*functionPointer)(Param1, Param2, Param3, Param4, Param5) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new StoredFunctorCall5<T, T (*)(Param1, Param2, Param3, Param4, Param5) noexcept, Arg1, Arg2, Arg3, Arg4, Arg5>(functionPointer, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-template <typename T, typename Class>
-QFuture<T> run(const Class &object, T (Class::*fn)() noexcept)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall0<T, Class>::type(fn, object))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1) noexcept, const Arg1 &arg1)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2) noexcept, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-template <typename T, typename Class>
-QFuture<T> run(const Class &object, T (Class::*fn)() const noexcept)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall0<T, Class>::type(fn, object))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1) const noexcept, const Arg1 &arg1)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2) const noexcept, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-template <typename T, typename Class>
-QFuture<T> run(Class *object, T (Class::*fn)() noexcept)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall0<T, Class>::type(fn, object))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(Class *object, T (Class::*fn)(Param1) noexcept, const Arg1 &arg1)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2) noexcept, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2, Param3) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
-}
-
-template <typename T, typename Class>
-QFuture<T> run(const Class *object, T (Class::*fn)() const noexcept)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall0<T, Class>::type(fn, object))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(const Class *object, T (Class::*fn)(Param1) const noexcept, const Arg1 &arg1)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2) const noexcept, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2, Param3) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
-}
-template <typename T>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)() noexcept)
-{
-    return (new StoredFunctorCall0<T, T (*)() noexcept>(functionPointer))->start(pool);
-}
-template <typename T, typename Param1, typename Arg1>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)(Param1) noexcept, const Arg1 &arg1)
-{
-    return (new StoredFunctorCall1<T, T (*)(Param1) noexcept, Arg1>(functionPointer, arg1))->start(pool);
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)(Param1, Param2) noexcept, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new StoredFunctorCall2<T, T (*)(Param1, Param2) noexcept, Arg1, Arg2>(functionPointer, arg1, arg2))->start(pool);
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)(Param1, Param2, Param3) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new StoredFunctorCall3<T, T (*)(Param1, Param2, Param3) noexcept, Arg1, Arg2, Arg3>(functionPointer, arg1, arg2, arg3))->start(pool);
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)(Param1, Param2, Param3, Param4) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new StoredFunctorCall4<T, T (*)(Param1, Param2, Param3, Param4) noexcept, Arg1, Arg2, Arg3, Arg4>(functionPointer, arg1, arg2, arg3, arg4))->start(pool);
-}
-template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(QThreadPool *pool, T (*functionPointer)(Param1, Param2, Param3, Param4, Param5) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new StoredFunctorCall5<T, T (*)(Param1, Param2, Param3, Param4, Param5) noexcept, Arg1, Arg2, Arg3, Arg4, Arg5>(functionPointer, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-template <typename T, typename Class>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)() noexcept)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall0<T, Class>::type(fn, object))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1) noexcept, const Arg1 &arg1)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2) noexcept, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-template <typename T, typename Class>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)() const noexcept)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall0<T, Class>::type(fn, object))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1) const noexcept, const Arg1 &arg1)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2) const noexcept, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(QThreadPool *pool, const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-template <typename T, typename Class>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)() noexcept)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall0<T, Class>::type(fn, object))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)(Param1) noexcept, const Arg1 &arg1)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)(Param1, Param2) noexcept, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)(Param1, Param2, Param3) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(QThreadPool *pool, Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredNoExceptMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-
-template <typename T, typename Class>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)() const noexcept)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall0<T, Class>::type(fn, object))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)(Param1) const noexcept, const Arg1 &arg1)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)(Param1, Param2) const noexcept, const Arg1 &arg1, const Arg2 &arg2)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)(Param1, Param2, Param3) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start(pool);
-}
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-QFuture<T> run(QThreadPool *pool, const Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
-{
-    return (new typename SelectStoredConstNoExceptMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start(pool);
-}
-#endif
 
 } //namespace QtConcurrent
 
diff --git a/src/concurrent/qtconcurrentstoredfunctioncall.h b/src/concurrent/qtconcurrentstoredfunctioncall.h
index 209832e5bb..e2d0e3de0f 100644
--- a/src/concurrent/qtconcurrentstoredfunctioncall.h
+++ b/src/concurrent/qtconcurrentstoredfunctioncall.h
@@ -37,7 +37,6 @@
 **
 ****************************************************************************/
 
-// Generated code, do not edit! Use generator at tools/qtconcurrent/generaterun/
 #ifndef QTCONCURRENT_STOREDFUNCTIONCALL_H
 #define QTCONCURRENT_STOREDFUNCTIONCALL_H
 
@@ -45,6 +44,7 @@
 
 #ifndef QT_NO_CONCURRENT
 #include <QtConcurrent/qtconcurrentrunbase.h>
+#include <type_traits>
 
 QT_BEGIN_NAMESPACE
 
@@ -52,2204 +52,50 @@ QT_BEGIN_NAMESPACE
 #ifndef Q_QDOC
 
 namespace QtConcurrent {
-template <typename T, typename FunctionPointer>
-struct StoredFunctorCall0: public RunFunctionTask<T>
-{
-    inline StoredFunctorCall0(FunctionPointer _function)
-      : function(_function) {}
-    void runFunctor() override { this->result = function(); }
-    FunctionPointer function;
-
-};
-
-template <typename FunctionPointer>
-struct StoredFunctorCall0<void, FunctionPointer>: public RunFunctionTask<void>
-{
-    inline StoredFunctorCall0(FunctionPointer _function)
-      : function(_function) {}
-    void runFunctor() override { function(); }
-    FunctionPointer function;
-
-};
-
-template <typename T, typename FunctionPointer>
-struct StoredFunctorPointerCall0: public RunFunctionTask<T>
-{
-    inline StoredFunctorPointerCall0(FunctionPointer * _function)
-      : function(_function) {}
-    void runFunctor() override { this->result =(*function)(); }
-    FunctionPointer * function;
-
-};
-
-template <typename T, typename FunctionPointer>
-struct VoidStoredFunctorPointerCall0: public RunFunctionTask<T>
-{
-    inline VoidStoredFunctorPointerCall0(FunctionPointer * _function)
-      : function(_function) {}
-    void runFunctor() override { (*function)(); }
-    FunctionPointer * function;
-
-};
-
-template <typename T, typename FunctionPointer>
-struct SelectStoredFunctorPointerCall0
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredFunctorPointerCall0    <T, FunctionPointer>,
-             VoidStoredFunctorPointerCall0<T, FunctionPointer> >::type type;
-};
-template <typename T, typename Class>
-class StoredMemberFunctionCall0 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionCall0(T (Class::*_fn)(), const Class &_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)();
-    }
-private:
-    T (Class::*fn)();
-    Class object;
-
-};
-template <typename T, typename Class>
-class VoidStoredMemberFunctionCall0 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionCall0(T (Class::*_fn)(), const Class &_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)();
-    }
-private:
-    T (Class::*fn)();
-    Class object;
-
-};
-template <typename T, typename Class>
-struct SelectStoredMemberFunctionCall0
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionCall0    <T, Class>,
-             VoidStoredMemberFunctionCall0<T, Class> >::type type;
-};
-template <typename T, typename Class>
-class StoredConstMemberFunctionCall0 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)();
-    }
-private:
-    T (Class::*fn)() const;
-    const Class object;
-
-};
-template <typename T, typename Class>
-class VoidStoredConstMemberFunctionCall0 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)();
-    }
-private:
-    T (Class::*fn)() const;
-    const Class object;
-
-};
-template <typename T, typename Class>
-struct SelectStoredConstMemberFunctionCall0
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionCall0    <T, Class>,
-             VoidStoredConstMemberFunctionCall0<T, Class> >::type type;
-};
-template <typename T, typename Class>
-class StoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionPointerCall0(T (Class::*_fn)(), Class *_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)();
-    }
-private:
-    T (Class::*fn)();
-    Class *object;
-
-};
-template <typename T, typename Class>
-class VoidStoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionPointerCall0(T (Class::*_fn)(), Class *_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)();
-    }
-private:
-    T (Class::*fn)();
-    Class *object;
-
-};
-template <typename T, typename Class>
-struct SelectStoredMemberFunctionPointerCall0
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionPointerCall0    <T, Class>,
-             VoidStoredMemberFunctionPointerCall0<T, Class> >::type type;
-};
-template <typename T, typename Class>
-class StoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)();
-    }
-private:
-    T (Class::*fn)() const;
-    Class const *object;
-
-};
-template <typename T, typename Class>
-class VoidStoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)();
-    }
-private:
-    T (Class::*fn)() const;
-    Class const *object;
-
-};
-template <typename T, typename Class>
-struct SelectStoredConstMemberFunctionPointerCall0
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionPointerCall0    <T, Class>,
-             VoidStoredConstMemberFunctionPointerCall0<T, Class> >::type type;
-};
-#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
-template <typename T, typename Class>
-class StoredNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionCall0(T (Class::*_fn)() noexcept, const Class &_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)();
-    }
-private:
-    T (Class::*fn)() noexcept;
-    Class object;
-
-};
-template <typename T, typename Class>
-class VoidStoredNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionCall0(T (Class::*_fn)() noexcept, const Class &_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)();
-    }
-private:
-    T (Class::*fn)() noexcept;
-    Class object;
-
-};
-template <typename T, typename Class>
-struct SelectStoredNoExceptMemberFunctionCall0
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionCall0    <T, Class>,
-             VoidStoredNoExceptMemberFunctionCall0<T, Class> >::type type;
-};
-template <typename T, typename Class>
-class StoredConstNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionCall0(T (Class::*_fn)() const noexcept, const Class &_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)();
-    }
-private:
-    T (Class::*fn)() const noexcept;
-    const Class object;
-
-};
-template <typename T, typename Class>
-class VoidStoredConstNoExceptMemberFunctionCall0 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionCall0(T (Class::*_fn)() const noexcept, const Class &_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)();
-    }
-private:
-    T (Class::*fn)() const noexcept;
-    const Class object;
-
-};
-template <typename T, typename Class>
-struct SelectStoredConstNoExceptMemberFunctionCall0
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionCall0    <T, Class>,
-             VoidStoredConstNoExceptMemberFunctionCall0<T, Class> >::type type;
-};
-template <typename T, typename Class>
-class StoredNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() noexcept, Class *_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)();
-    }
-private:
-    T (Class::*fn)() noexcept;
-    Class *object;
-
-};
-template <typename T, typename Class>
-class VoidStoredNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() noexcept, Class *_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)();
-    }
-private:
-    T (Class::*fn)() noexcept;
-    Class *object;
-
-};
-template <typename T, typename Class>
-struct SelectStoredNoExceptMemberFunctionPointerCall0
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionPointerCall0    <T, Class>,
-             VoidStoredNoExceptMemberFunctionPointerCall0<T, Class> >::type type;
-};
-template <typename T, typename Class>
-class StoredConstNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() const noexcept, Class const *_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)();
-    }
-private:
-    T (Class::*fn)() const noexcept;
-    Class const *object;
-
-};
-template <typename T, typename Class>
-class VoidStoredConstNoExceptMemberFunctionPointerCall0 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionPointerCall0(T (Class::*_fn)() const noexcept, Class const *_object)
-    : fn(_fn), object(_object){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)();
-    }
-private:
-    T (Class::*fn)() const noexcept;
-    Class const *object;
-
-};
-template <typename T, typename Class>
-struct SelectStoredConstNoExceptMemberFunctionPointerCall0
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionPointerCall0    <T, Class>,
-             VoidStoredConstNoExceptMemberFunctionPointerCall0<T, Class> >::type type;
-};
-#endif
 
-template <typename T, typename FunctionPointer, typename Arg1>
-struct StoredFunctorCall1: public RunFunctionTask<T>
+template <class Function, class ...Args>
+struct InvokeResult
 {
-    inline StoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1)
-      : function(_function), arg1(_arg1) {}
-    void runFunctor() override { this->result = function(arg1); }
-    FunctionPointer function;
-    Arg1 arg1;
-};
+    static_assert(std::is_invocable_v<std::decay_t<Function>, std::decay_t<Args>...>,
+                  "It's not possible to invoke the function with passed arguments.");
 
-template <typename FunctionPointer, typename Arg1>
-struct StoredFunctorCall1<void, FunctionPointer, Arg1>: public RunFunctionTask<void>
-{
-    inline StoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1)
-      : function(_function), arg1(_arg1) {}
-    void runFunctor() override { function(arg1); }
-    FunctionPointer function;
-    Arg1 arg1;
+    using Type = std::invoke_result_t<std::decay_t<Function>, std::decay_t<Args>...>;
 };
 
-template <typename T, typename FunctionPointer, typename Arg1>
-struct StoredFunctorPointerCall1: public RunFunctionTask<T>
-{
-    inline StoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1)
-      : function(_function), arg1(_arg1) {}
-    void runFunctor() override { this->result =(*function)(arg1); }
-    FunctionPointer * function;
-    Arg1 arg1;
-};
+template <class Function, class ...Args>
+using InvokeResultType = typename InvokeResult<Function, Args...>::Type;
 
-template <typename T, typename FunctionPointer, typename Arg1>
-struct VoidStoredFunctorPointerCall1: public RunFunctionTask<T>
+template <class Function, class ...Args>
+struct StoredFunctionCall : public RunFunctionTask<InvokeResultType<Function, Args...>>
 {
-    inline VoidStoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1)
-      : function(_function), arg1(_arg1) {}
-    void runFunctor() override { (*function)(arg1); }
-    FunctionPointer * function;
-    Arg1 arg1;
-};
+    template <class ...Types>
+    using DecayedTuple = std::tuple<std::decay_t<Types>...>;
 
-template <typename T, typename FunctionPointer, typename Arg1>
-struct SelectStoredFunctorPointerCall1
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredFunctorPointerCall1    <T, FunctionPointer, Arg1>,
-             VoidStoredFunctorPointerCall1<T, FunctionPointer, Arg1> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class StoredMemberFunctionCall1 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionCall1(T (Class::*_fn)(Param1), const Class &_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
+    StoredFunctionCall(Function &&f, Args &&...args)
+        : data{std::forward<Function>(f), std::forward<Args>(args)...}
+    {}
 
     void runFunctor() override
     {
-        this->result = (object.*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1);
-    Class object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class VoidStoredMemberFunctionCall1 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionCall1(T (Class::*_fn)(Param1), const Class &_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
+        using Indexes =
+            std::make_index_sequence<
+                std::tuple_size<DecayedTuple<Function, Args...>>::value>;
 
-    void runFunctor() override
-    {
-        (object.*fn)(arg1);
+        invoke(Indexes());
     }
-private:
-    T (Class::*fn)(Param1);
-    Class object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-struct SelectStoredMemberFunctionCall1
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionCall1    <T, Class, Param1, Arg1>,
-             VoidStoredMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class StoredConstMemberFunctionCall1 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
 
-    void runFunctor() override
+    template <std::size_t... I>
+    void invoke(std::index_sequence<I...>)
     {
-        this->result = (object.*fn)(arg1);
+        if constexpr (std::is_void_v<InvokeResultType<Function, Args...>>)
+            std::invoke(std::get<I>(std::move(data))...);
+        else
+            this->result = std::invoke(std::get<I>(std::move(data))...);
     }
-private:
-    T (Class::*fn)(Param1) const;
-    const Class object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class VoidStoredConstMemberFunctionCall1 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
 
-    void runFunctor() override
-    {
-        (object.*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1) const;
-    const Class object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-struct SelectStoredConstMemberFunctionCall1
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionCall1    <T, Class, Param1, Arg1>,
-             VoidStoredConstMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class StoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1), Class *_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1);
-    Class *object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class VoidStoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1), Class *_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1);
-    Class *object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-struct SelectStoredMemberFunctionPointerCall1
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionPointerCall1    <T, Class, Param1, Arg1>,
-             VoidStoredMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class StoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1) const;
-    Class const *object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class VoidStoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1) const;
-    Class const *object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-struct SelectStoredConstMemberFunctionPointerCall1
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionPointerCall1    <T, Class, Param1, Arg1>,
-             VoidStoredConstMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
-};
-#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
-template <typename T, typename Class, typename Param1, typename Arg1>
-class StoredNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) noexcept, const Class &_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1) noexcept;
-    Class object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class VoidStoredNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) noexcept, const Class &_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1) noexcept;
-    Class object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-struct SelectStoredNoExceptMemberFunctionCall1
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionCall1    <T, Class, Param1, Arg1>,
-             VoidStoredNoExceptMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class StoredConstNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) const noexcept, const Class &_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1) const noexcept;
-    const Class object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class VoidStoredConstNoExceptMemberFunctionCall1 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionCall1(T (Class::*_fn)(Param1) const noexcept, const Class &_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1) const noexcept;
-    const Class object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-struct SelectStoredConstNoExceptMemberFunctionCall1
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionCall1    <T, Class, Param1, Arg1>,
-             VoidStoredConstNoExceptMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class StoredNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) noexcept, Class *_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1) noexcept;
-    Class *object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class VoidStoredNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) noexcept, Class *_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1) noexcept;
-    Class *object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-struct SelectStoredNoExceptMemberFunctionPointerCall1
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionPointerCall1    <T, Class, Param1, Arg1>,
-             VoidStoredNoExceptMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class StoredConstNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const noexcept, Class const *_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1) const noexcept;
-    Class const *object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-class VoidStoredConstNoExceptMemberFunctionPointerCall1 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const noexcept, Class const *_object, const Arg1 &_arg1)
-    : fn(_fn), object(_object), arg1(_arg1){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1);
-    }
-private:
-    T (Class::*fn)(Param1) const noexcept;
-    Class const *object;
-    Arg1 arg1;
-};
-template <typename T, typename Class, typename Param1, typename Arg1>
-struct SelectStoredConstNoExceptMemberFunctionPointerCall1
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionPointerCall1    <T, Class, Param1, Arg1>,
-             VoidStoredConstNoExceptMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
-};
-#endif
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
-struct StoredFunctorCall2: public RunFunctionTask<T>
-{
-    inline StoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2)
-      : function(_function), arg1(_arg1), arg2(_arg2) {}
-    void runFunctor() override { this->result = function(arg1, arg2); }
-    FunctionPointer function;
-    Arg1 arg1; Arg2 arg2;
-};
-
-template <typename FunctionPointer, typename Arg1, typename Arg2>
-struct StoredFunctorCall2<void, FunctionPointer, Arg1, Arg2>: public RunFunctionTask<void>
-{
-    inline StoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2)
-      : function(_function), arg1(_arg1), arg2(_arg2) {}
-    void runFunctor() override { function(arg1, arg2); }
-    FunctionPointer function;
-    Arg1 arg1; Arg2 arg2;
-};
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
-struct StoredFunctorPointerCall2: public RunFunctionTask<T>
-{
-    inline StoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2)
-      : function(_function), arg1(_arg1), arg2(_arg2) {}
-    void runFunctor() override { this->result =(*function)(arg1, arg2); }
-    FunctionPointer * function;
-    Arg1 arg1; Arg2 arg2;
-};
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
-struct VoidStoredFunctorPointerCall2: public RunFunctionTask<T>
-{
-    inline VoidStoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2)
-      : function(_function), arg1(_arg1), arg2(_arg2) {}
-    void runFunctor() override { (*function)(arg1, arg2); }
-    FunctionPointer * function;
-    Arg1 arg1; Arg2 arg2;
-};
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
-struct SelectStoredFunctorPointerCall2
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredFunctorPointerCall2    <T, FunctionPointer, Arg1, Arg2>,
-             VoidStoredFunctorPointerCall2<T, FunctionPointer, Arg1, Arg2> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class StoredMemberFunctionCall2 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2);
-    Class object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class VoidStoredMemberFunctionCall2 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2);
-    Class object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-struct SelectStoredMemberFunctionCall2
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
-             VoidStoredMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class StoredConstMemberFunctionCall2 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) const;
-    const Class object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class VoidStoredConstMemberFunctionCall2 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) const;
-    const Class object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-struct SelectStoredConstMemberFunctionCall2
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
-             VoidStoredConstMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class StoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2);
-    Class *object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class VoidStoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2);
-    Class *object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-struct SelectStoredMemberFunctionPointerCall2
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionPointerCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
-             VoidStoredMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class StoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) const;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class VoidStoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) const;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-struct SelectStoredConstMemberFunctionPointerCall2
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionPointerCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
-             VoidStoredConstMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
-};
-#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class StoredNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) noexcept;
-    Class object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class VoidStoredNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) noexcept;
-    Class object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-struct SelectStoredNoExceptMemberFunctionCall2
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
-             VoidStoredNoExceptMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class StoredConstNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) const noexcept;
-    const Class object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class VoidStoredConstNoExceptMemberFunctionCall2 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) const noexcept;
-    const Class object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-struct SelectStoredConstNoExceptMemberFunctionCall2
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
-             VoidStoredConstNoExceptMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class StoredNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) noexcept;
-    Class *object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class VoidStoredNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) noexcept;
-    Class *object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-struct SelectStoredNoExceptMemberFunctionPointerCall2
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionPointerCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
-             VoidStoredNoExceptMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class StoredConstNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) const noexcept;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-class VoidStoredConstNoExceptMemberFunctionPointerCall2 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2);
-    }
-private:
-    T (Class::*fn)(Param1, Param2) const noexcept;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
-struct SelectStoredConstNoExceptMemberFunctionPointerCall2
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionPointerCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
-             VoidStoredConstNoExceptMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
-};
-#endif
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
-struct StoredFunctorCall3: public RunFunctionTask<T>
-{
-    inline StoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
-    void runFunctor() override { this->result = function(arg1, arg2, arg3); }
-    FunctionPointer function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-
-template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
-struct StoredFunctorCall3<void, FunctionPointer, Arg1, Arg2, Arg3>: public RunFunctionTask<void>
-{
-    inline StoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
-    void runFunctor() override { function(arg1, arg2, arg3); }
-    FunctionPointer function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+    DecayedTuple<Function, Args...> data;
 };
 
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
-struct StoredFunctorPointerCall3: public RunFunctionTask<T>
-{
-    inline StoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
-    void runFunctor() override { this->result =(*function)(arg1, arg2, arg3); }
-    FunctionPointer * function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
-struct VoidStoredFunctorPointerCall3: public RunFunctionTask<T>
-{
-    inline VoidStoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
-    void runFunctor() override { (*function)(arg1, arg2, arg3); }
-    FunctionPointer * function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
-struct SelectStoredFunctorPointerCall3
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredFunctorPointerCall3    <T, FunctionPointer, Arg1, Arg2, Arg3>,
-             VoidStoredFunctorPointerCall3<T, FunctionPointer, Arg1, Arg2, Arg3> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class StoredMemberFunctionCall3 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3);
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class VoidStoredMemberFunctionCall3 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3);
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-struct SelectStoredMemberFunctionCall3
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
-             VoidStoredMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class StoredConstMemberFunctionCall3 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) const;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class VoidStoredConstMemberFunctionCall3 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) const;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-struct SelectStoredConstMemberFunctionCall3
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
-             VoidStoredConstMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class StoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3);
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class VoidStoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3);
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-struct SelectStoredMemberFunctionPointerCall3
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionPointerCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
-             VoidStoredMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class StoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) const;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class VoidStoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) const;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-struct SelectStoredConstMemberFunctionPointerCall3
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionPointerCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
-             VoidStoredConstMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
-};
-#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class StoredNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) noexcept;
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class VoidStoredNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) noexcept;
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-struct SelectStoredNoExceptMemberFunctionCall3
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
-             VoidStoredNoExceptMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class StoredConstNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) const noexcept;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class VoidStoredConstNoExceptMemberFunctionCall3 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) const noexcept;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-struct SelectStoredConstNoExceptMemberFunctionCall3
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
-             VoidStoredConstNoExceptMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class StoredNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) noexcept;
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class VoidStoredNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) noexcept;
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-struct SelectStoredNoExceptMemberFunctionPointerCall3
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionPointerCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
-             VoidStoredNoExceptMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class StoredConstNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) const noexcept;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-class VoidStoredConstNoExceptMemberFunctionPointerCall3 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3) const noexcept;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
-struct SelectStoredConstNoExceptMemberFunctionPointerCall3
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionPointerCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
-             VoidStoredConstNoExceptMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
-};
-#endif
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-struct StoredFunctorCall4: public RunFunctionTask<T>
-{
-    inline StoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
-    void runFunctor() override { this->result = function(arg1, arg2, arg3, arg4); }
-    FunctionPointer function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-
-template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-struct StoredFunctorCall4<void, FunctionPointer, Arg1, Arg2, Arg3, Arg4>: public RunFunctionTask<void>
-{
-    inline StoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
-    void runFunctor() override { function(arg1, arg2, arg3, arg4); }
-    FunctionPointer function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-struct StoredFunctorPointerCall4: public RunFunctionTask<T>
-{
-    inline StoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
-    void runFunctor() override { this->result =(*function)(arg1, arg2, arg3, arg4); }
-    FunctionPointer * function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-struct VoidStoredFunctorPointerCall4: public RunFunctionTask<T>
-{
-    inline VoidStoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
-    void runFunctor() override { (*function)(arg1, arg2, arg3, arg4); }
-    FunctionPointer * function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-struct SelectStoredFunctorPointerCall4
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredFunctorPointerCall4    <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4>,
-             VoidStoredFunctorPointerCall4<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class StoredMemberFunctionCall4 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4);
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class VoidStoredMemberFunctionCall4 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4);
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-struct SelectStoredMemberFunctionCall4
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
-             VoidStoredMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class StoredConstMemberFunctionCall4 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) const;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class VoidStoredConstMemberFunctionCall4 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) const;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-struct SelectStoredConstMemberFunctionCall4
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
-             VoidStoredConstMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class StoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4);
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class VoidStoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4);
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-struct SelectStoredMemberFunctionPointerCall4
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionPointerCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
-             VoidStoredMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class StoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) const;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class VoidStoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) const;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-struct SelectStoredConstMemberFunctionPointerCall4
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionPointerCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
-             VoidStoredConstMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
-};
-#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class StoredNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class VoidStoredNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-struct SelectStoredNoExceptMemberFunctionCall4
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
-             VoidStoredNoExceptMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class StoredConstNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class VoidStoredConstNoExceptMemberFunctionCall4 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-struct SelectStoredConstNoExceptMemberFunctionCall4
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
-             VoidStoredConstNoExceptMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class StoredNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class VoidStoredNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) noexcept;
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-struct SelectStoredNoExceptMemberFunctionPointerCall4
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionPointerCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
-             VoidStoredNoExceptMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class StoredConstNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-class VoidStoredConstNoExceptMemberFunctionPointerCall4 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3, arg4);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4) const noexcept;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
-struct SelectStoredConstNoExceptMemberFunctionPointerCall4
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionPointerCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
-             VoidStoredConstNoExceptMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
-};
-#endif
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-struct StoredFunctorCall5: public RunFunctionTask<T>
-{
-    inline StoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
-    void runFunctor() override { this->result = function(arg1, arg2, arg3, arg4, arg5); }
-    FunctionPointer function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-
-template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-struct StoredFunctorCall5<void, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>: public RunFunctionTask<void>
-{
-    inline StoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
-    void runFunctor() override { function(arg1, arg2, arg3, arg4, arg5); }
-    FunctionPointer function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-struct StoredFunctorPointerCall5: public RunFunctionTask<T>
-{
-    inline StoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
-    void runFunctor() override { this->result =(*function)(arg1, arg2, arg3, arg4, arg5); }
-    FunctionPointer * function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-struct VoidStoredFunctorPointerCall5: public RunFunctionTask<T>
-{
-    inline VoidStoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
-    void runFunctor() override { (*function)(arg1, arg2, arg3, arg4, arg5); }
-    FunctionPointer * function;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-
-template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
-struct SelectStoredFunctorPointerCall5
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredFunctorPointerCall5    <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>,
-             VoidStoredFunctorPointerCall5<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class StoredMemberFunctionCall5 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class VoidStoredMemberFunctionCall5 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-struct SelectStoredMemberFunctionCall5
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
-             VoidStoredMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class StoredConstMemberFunctionCall5 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class VoidStoredConstMemberFunctionCall5 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-struct SelectStoredConstMemberFunctionCall5
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
-             VoidStoredConstMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class StoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
-{
-public:
-    StoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class VoidStoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-struct SelectStoredMemberFunctionPointerCall5
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredMemberFunctionPointerCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
-             VoidStoredMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class StoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
-{
-public:
-    StoredConstMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class VoidStoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-struct SelectStoredConstMemberFunctionPointerCall5
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstMemberFunctionPointerCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
-             VoidStoredConstMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
-};
-#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class StoredNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept;
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class VoidStoredNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept;
-    Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-struct SelectStoredNoExceptMemberFunctionCall5
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
-             VoidStoredNoExceptMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class StoredConstNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class VoidStoredConstNoExceptMemberFunctionCall5 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        (object.*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept;
-    const Class object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-struct SelectStoredConstNoExceptMemberFunctionCall5
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
-             VoidStoredConstNoExceptMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class StoredNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
-{
-public:
-    StoredNoExceptMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept;
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class VoidStoredNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredNoExceptMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) noexcept, Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) noexcept;
-    Class *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-struct SelectStoredNoExceptMemberFunctionPointerCall5
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredNoExceptMemberFunctionPointerCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
-             VoidStoredNoExceptMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class StoredConstNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
-{
-public:
-    StoredConstNoExceptMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-class VoidStoredConstNoExceptMemberFunctionPointerCall5 : public RunFunctionTask<T>
-{
-public:
-    VoidStoredConstNoExceptMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const noexcept, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
-    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
-
-    void runFunctor() override
-    {
-        (object->*fn)(arg1, arg2, arg3, arg4, arg5);
-    }
-private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const noexcept;
-    Class const *object;
-    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
-};
-template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
-struct SelectStoredConstNoExceptMemberFunctionPointerCall5
-{
-    typedef typename SelectSpecialization<T>::template
-        Type<StoredConstNoExceptMemberFunctionPointerCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
-             VoidStoredConstNoExceptMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
-};
-#endif
-
-template <typename T, typename Functor>
-class StoredFunctorCall : public RunFunctionTask<T>
-{
-public:
-    StoredFunctorCall(const Functor &f) : functor(f) { }
-    void runFunctor() override
-    {
-        this->result = functor();
-    }
-private:
-    Functor functor;
-};
-template <typename Functor>
-class StoredFunctorCall<void, Functor> : public RunFunctionTask<void>
-{
-public:
-    StoredFunctorCall(const Functor &f) : functor(f) { }
-    void runFunctor() override
-    {
-        functor();
-    }
-private:
-    Functor functor;
-};
-
-
 } //namespace QtConcurrent
 
 #endif // Q_QDOC
diff --git a/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp b/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp
index a4eb2936b5..c0782d8483 100644
--- a/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp
+++ b/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp
@@ -50,6 +50,7 @@ private slots:
 #endif
     void functor();
     void lambda();
+    void callableObjectWithState();
 };
 
 void light()
@@ -152,24 +153,24 @@ void tst_QtConcurrentRun::returnValue()
     QCOMPARE(f.result(), 10);
 
     A a;
-    f = run(&a, &A::member0);
+    f = run(&A::member0, &a);
     QCOMPARE(f.result(), 10);
-    f = run(&pool, &a, &A::member0);
+    f = run(&pool, &A::member0, &a);
     QCOMPARE(f.result(), 10);
 
-    f = run(&a, &A::member1, 20);
+    f = run(&A::member1, &a, 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, &a, &A::member1, 20);
+    f = run(&pool, &A::member1, &a, 20);
     QCOMPARE(f.result(), 20);
 
-    f = run(a, &A::member0);
+    f = run(&A::member0, a);
     QCOMPARE(f.result(), 10);
-    f = run(&pool, a, &A::member0);
+    f = run(&pool, &A::member0, a);
     QCOMPARE(f.result(), 10);
 
-    f = run(a, &A::member1, 20);
+    f = run(&A::member1, a, 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, a, &A::member1, 20);
+    f = run(&pool, &A::member1, a, 20);
     QCOMPARE(f.result(), 20);
 
     f = run(a);
@@ -177,9 +178,9 @@ void tst_QtConcurrentRun::returnValue()
     f = run(&pool, a);
     QCOMPARE(f.result(), 10);
 
-    f = run(&a);
+    f = run(a);
     QCOMPARE(f.result(), 10);
-    f = run(&pool, &a);
+    f = run(&pool, std::ref(a));
     QCOMPARE(f.result(), 10);
 
     f = run(a, 20);
@@ -187,30 +188,30 @@ void tst_QtConcurrentRun::returnValue()
     f = run(&pool, a, 20);
     QCOMPARE(f.result(), 20);
 
-    f = run(&a, 20);
+    f = run(std::ref(a), 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, &a, 20);
+    f = run(&pool, std::ref(a), 20);
     QCOMPARE(f.result(), 20);
 
     const AConst aConst = AConst();
-    f = run(&aConst, &AConst::member0);
+    f = run(&AConst::member0, &aConst);
     QCOMPARE(f.result(), 10);
-    f = run(&pool, &aConst, &AConst::member0);
+    f = run(&pool, &AConst::member0, &aConst);
     QCOMPARE(f.result(), 10);
 
-    f = run(&aConst, &AConst::member1, 20);
+    f = run(&AConst::member1, &aConst, 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, &aConst, &AConst::member1, 20);
+    f = run(&pool, &AConst::member1, &aConst, 20);
     QCOMPARE(f.result(), 20);
 
-    f = run(aConst, &AConst::member0);
+    f = run(&AConst::member0, aConst);
     QCOMPARE(f.result(), 10);
-    f = run(&pool, aConst, &AConst::member0);
+    f = run(&pool, &AConst::member0, aConst);
     QCOMPARE(f.result(), 10);
 
-    f = run(aConst, &AConst::member1, 20);
+    f = run(&AConst::member1, aConst, 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, aConst, &AConst::member1, 20);
+    f = run(&pool, &AConst::member1, aConst, 20);
     QCOMPARE(f.result(), 20);
 
     f = run(aConst);
@@ -218,9 +219,9 @@ void tst_QtConcurrentRun::returnValue()
     f = run(&pool, aConst);
     QCOMPARE(f.result(), 10);
 
-    f = run(&aConst);
+    f = run(std::ref(a));
     QCOMPARE(f.result(), 10);
-    f = run(&pool, &aConst);
+    f = run(&pool, std::ref(a));
     QCOMPARE(f.result(), 10);
 
     f = run(aConst, 20);
@@ -228,30 +229,30 @@ void tst_QtConcurrentRun::returnValue()
     f = run(&pool, aConst, 20);
     QCOMPARE(f.result(), 20);
 
-    f = run(&aConst, 20);
+    f = run(std::ref(aConst), 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, &aConst, 20);
+    f = run(&pool, std::ref(aConst), 20);
     QCOMPARE(f.result(), 20);
 
     ANoExcept aNoExcept;
-    f = run(&aNoExcept, &ANoExcept::member0);
+    f = run(&ANoExcept::member0, &aNoExcept);
     QCOMPARE(f.result(), 10);
-    f = run(&pool, &aNoExcept, &ANoExcept::member0);
+    f = run(&pool, &ANoExcept::member0, &aNoExcept);
     QCOMPARE(f.result(), 10);
 
-    f = run(&aNoExcept, &ANoExcept::member1, 20);
+    f = run(&ANoExcept::member1, &aNoExcept, 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, &aNoExcept, &ANoExcept::member1, 20);
+    f = run(&pool, &ANoExcept::member1, &aNoExcept, 20);
     QCOMPARE(f.result(), 20);
 
-    f = run(aNoExcept, &ANoExcept::member0);
+    f = run(&ANoExcept::member0, aNoExcept);
     QCOMPARE(f.result(), 10);
-    f = run(&pool, aNoExcept, &ANoExcept::member0);
+    f = run(&pool, &ANoExcept::member0, aNoExcept);
     QCOMPARE(f.result(), 10);
 
-    f = run(aNoExcept, &ANoExcept::member1, 20);
+    f = run(&ANoExcept::member1, aNoExcept, 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, aNoExcept, &ANoExcept::member1, 20);
+    f = run(&pool, &ANoExcept::member1, aNoExcept, 20);
     QCOMPARE(f.result(), 20);
 
     f = run(aNoExcept);
@@ -259,9 +260,9 @@ void tst_QtConcurrentRun::returnValue()
     f = run(&pool, aNoExcept);
     QCOMPARE(f.result(), 10);
 
-    f = run(&aNoExcept);
+    f = run(std::ref(aNoExcept));
     QCOMPARE(f.result(), 10);
-    f = run(&pool, &aNoExcept);
+    f = run(&pool, std::ref(aNoExcept));
     QCOMPARE(f.result(), 10);
 
     f = run(aNoExcept, 20);
@@ -269,30 +270,30 @@ void tst_QtConcurrentRun::returnValue()
     f = run(&pool, aNoExcept, 20);
     QCOMPARE(f.result(), 20);
 
-    f = run(&aNoExcept, 20);
+    f = run(std::ref(aNoExcept), 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, &aNoExcept, 20);
+    f = run(&pool, std::ref(aNoExcept), 20);
     QCOMPARE(f.result(), 20);
 
     const AConstNoExcept aConstNoExcept = AConstNoExcept();
-    f = run(&aConstNoExcept, &AConstNoExcept::member0);
+    f = run(&AConstNoExcept::member0, &aConstNoExcept);
     QCOMPARE(f.result(), 10);
-    f = run(&pool, &aConstNoExcept, &AConstNoExcept::member0);
+    f = run(&pool, &AConstNoExcept::member0, &aConstNoExcept);
     QCOMPARE(f.result(), 10);
 
-    f = run(&aConstNoExcept, &AConstNoExcept::member1, 20);
+    f = run(&AConstNoExcept::member1, &aConstNoExcept, 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, &aConstNoExcept, &AConstNoExcept::member1, 20);
+    f = run(&pool, &AConstNoExcept::member1, &aConstNoExcept, 20);
     QCOMPARE(f.result(), 20);
 
-    f = run(aConstNoExcept, &AConstNoExcept::member0);
+    f = run(&AConstNoExcept::member0, aConstNoExcept);
     QCOMPARE(f.result(), 10);
-    f = run(&pool, aConstNoExcept, &AConstNoExcept::member0);
+    f = run(&pool, &AConstNoExcept::member0, aConstNoExcept);
     QCOMPARE(f.result(), 10);
 
-    f = run(aConstNoExcept, &AConstNoExcept::member1, 20);
+    f = run(&AConstNoExcept::member1, aConstNoExcept, 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, aConstNoExcept, &AConstNoExcept::member1, 20);
+    f = run(&pool, &AConstNoExcept::member1, aConstNoExcept, 20);
     QCOMPARE(f.result(), 20);
 
     f = run(aConstNoExcept);
@@ -300,9 +301,9 @@ void tst_QtConcurrentRun::returnValue()
     f = run(&pool, aConstNoExcept);
     QCOMPARE(f.result(), 10);
 
-    f = run(&aConstNoExcept);
+    f = run(std::ref(aConstNoExcept));
     QCOMPARE(f.result(), 10);
-    f = run(&pool, &aConstNoExcept);
+    f = run(&pool, std::ref(aConstNoExcept));
     QCOMPARE(f.result(), 10);
 
     f = run(aConstNoExcept, 20);
@@ -310,9 +311,9 @@ void tst_QtConcurrentRun::returnValue()
     f = run(&pool, aConstNoExcept, 20);
     QCOMPARE(f.result(), 20);
 
-    f = run(&aConstNoExcept, 20);
+    f = run(std::ref(aConstNoExcept), 20);
     QCOMPARE(f.result(), 20);
-    f = run(&pool, &aConstNoExcept, 20);
+    f = run(&pool, std::ref(aConstNoExcept), 20);
     QCOMPARE(f.result(), 20);
 }
 
@@ -341,25 +342,25 @@ void tst_QtConcurrentRun::functionObject()
     TestClass c;
 
     f = run(c);
-    f = run(&c);
+    f = run(std::ref(c));
     f = run(c, 10);
-    f = run(&c, 10);
+    f = run(std::ref(c), 10);
 
     f = run(&pool, c);
-    f = run(&pool, &c);
+    f = run(&pool, std::ref(c));
     f = run(&pool, c, 10);
-    f = run(&pool, &c, 10);
+    f = run(&pool, std::ref(c), 10);
 
     const TestConstClass cc = TestConstClass();
     f = run(cc);
-    f = run(&cc);
+    f = run(std::ref(c));
     f = run(cc, 10);
-    f = run(&cc, 10);
+    f = run(std::ref(c), 10);
 
     f = run(&pool, cc);
-    f = run(&pool, &cc);
+    f = run(&pool, std::ref(c));
     f = run(&pool, cc, 10);
-    f = run(&pool, &cc, 10);
+    f = run(&pool, std::ref(c), 10);
 }
 
 
@@ -369,26 +370,26 @@ void tst_QtConcurrentRun::memberFunctions()
 
     TestClass c;
 
-    run(c, &TestClass::foo).waitForFinished();
-    run(&c, &TestClass::foo).waitForFinished();
-    run(c, &TestClass::fooInt, 10).waitForFinished();
-    run(&c, &TestClass::fooInt, 10).waitForFinished();
+    run(&TestClass::foo, c).waitForFinished();
+    run(&TestClass::foo, &c).waitForFinished();
+    run(&TestClass::fooInt, c, 10).waitForFinished();
+    run(&TestClass::fooInt, &c, 10).waitForFinished();
 
-    run(&pool, c, &TestClass::foo).waitForFinished();
-    run(&pool, &c, &TestClass::foo).waitForFinished();
-    run(&pool, c, &TestClass::fooInt, 10).waitForFinished();
-    run(&pool, &c, &TestClass::fooInt, 10).waitForFinished();
+    run(&pool, &TestClass::foo, c).waitForFinished();
+    run(&pool, &TestClass::foo, &c).waitForFinished();
+    run(&pool, &TestClass::fooInt, c, 10).waitForFinished();
+    run(&pool, &TestClass::fooInt, &c, 10).waitForFinished();
 
     const TestConstClass cc = TestConstClass();
-    run(cc, &TestConstClass::foo).waitForFinished();
-    run(&cc, &TestConstClass::foo).waitForFinished();
-    run(cc, &TestConstClass::fooInt, 10).waitForFinished();
-    run(&cc, &TestConstClass::fooInt, 10).waitForFinished();
+    run(&TestConstClass::foo, cc).waitForFinished();
+    run(&TestConstClass::foo, &cc).waitForFinished();
+    run(&TestConstClass::fooInt, cc, 10).waitForFinished();
+    run(&TestConstClass::fooInt, &cc, 10).waitForFinished();
 
-    run(&pool, cc, &TestConstClass::foo).waitForFinished();
-    run(&pool, &cc, &TestConstClass::foo).waitForFinished();
-    run(&pool, cc, &TestConstClass::fooInt, 10).waitForFinished();
-    run(&pool, &cc, &TestConstClass::fooInt, 10).waitForFinished();
+    run(&pool, &TestConstClass::foo, cc).waitForFinished();
+    run(&pool, &TestConstClass::foo, &cc).waitForFinished();
+    run(&pool, &TestConstClass::fooInt, cc, 10).waitForFinished();
+    run(&pool, &TestConstClass::fooInt, &cc, 10).waitForFinished();
 }
 
 
@@ -437,8 +438,8 @@ void tst_QtConcurrentRun::implicitConvertibleTypes()
     run(stringConstRefFunction, QLatin1String("Foo")).waitForFinished();
     run(&pool, stringConstRefFunction, QLatin1String("Foo")).waitForFinished();
     QString string;
-    run(stringRefFunction, string).waitForFinished();
-    run(&pool, stringRefFunction, string).waitForFinished();
+    run(stringRefFunction, std::ref(string)).waitForFinished();
+    run(&pool, stringRefFunction, std::ref(string)).waitForFinished();
 }
 
 void fn() { }
@@ -732,5 +733,34 @@ void tst_QtConcurrentRun::lambda()
     }
 }
 
+struct CallableWithState
+{
+    void setNewState(int newState) { state = newState; }
+    int operator()(int newState) { return (state = newState); }
+
+    static constexpr int defaultState() { return 42; }
+    int state = defaultState();
+};
+
+void tst_QtConcurrentRun::callableObjectWithState()
+{
+    CallableWithState o;
+
+    // Run method setNewState explicitly
+    run(&CallableWithState::setNewState, &o, CallableWithState::defaultState() + 1).waitForFinished();
+    QCOMPARE(o.state, CallableWithState::defaultState() + 1);
+
+    // Run operator()(int) explicitly
+    run(std::ref(o), CallableWithState::defaultState() + 2).waitForFinished();
+    QCOMPARE(o.state, CallableWithState::defaultState() + 2);
+
+    // Run on a copy of object (original object remains unchanged)
+    run(o, CallableWithState::defaultState() + 3).waitForFinished();
+    QCOMPARE(o.state, CallableWithState::defaultState() + 2);
+
+    // Explicitly run on a temporary object
+    QCOMPARE(run(CallableWithState(), 15).result(), 15);
+}
+
 QTEST_MAIN(tst_QtConcurrentRun)
 #include "tst_qtconcurrentrun.moc"
diff --git a/tests/auto/corelib/io/qlockfile/tst_qlockfile.cpp b/tests/auto/corelib/io/qlockfile/tst_qlockfile.cpp
index 4969e417f4..1d79d0dd1f 100644
--- a/tests/auto/corelib/io/qlockfile/tst_qlockfile.cpp
+++ b/tests/auto/corelib/io/qlockfile/tst_qlockfile.cpp
@@ -163,13 +163,13 @@ void tst_QLockFile::lockOutOtherThread()
     QVERIFY(lockFile.lock());
 
     // Other thread can't acquire lock
-    QFuture<QLockFile::LockError> ret = QtConcurrent::run<QLockFile::LockError>(tryLockFromThread, fileName);
+    auto ret = QtConcurrent::run(tryLockFromThread, fileName);
     QCOMPARE(ret.result(), QLockFile::LockFailedError);
 
     lockFile.unlock();
 
     // Now other thread can acquire lock
-    QFuture<QLockFile::LockError> ret2 = QtConcurrent::run<QLockFile::LockError>(tryLockFromThread, fileName);
+    auto ret2 = QtConcurrent::run(tryLockFromThread, fileName);
     QCOMPARE(ret2.result(), QLockFile::NoError);
 }
 
@@ -186,13 +186,13 @@ static QLockFile::LockError lockFromThread(const QString &fileName)
 void tst_QLockFile::raceWithOtherThread()
 {
     const QString fileName = dir.path() + "/raceWithOtherThread";
-    QFuture<QLockFile::LockError> ret = QtConcurrent::run<QLockFile::LockError>(lockFromThread, fileName);
-    QFuture<QLockFile::LockError> ret2 = QtConcurrent::run<QLockFile::LockError>(lockFromThread, fileName);
+    auto ret = QtConcurrent::run(lockFromThread, fileName);
+    auto ret2 = QtConcurrent::run(lockFromThread, fileName);
     QCOMPARE(ret.result(), QLockFile::NoError);
     QCOMPARE(ret2.result(), QLockFile::NoError);
 }
 
-static bool lockFromThread(const QString &fileName, int sleepMs, QSemaphore *semThreadReady, QSemaphore *semMainThreadDone)
+static bool lockFromThreadAndWait(const QString &fileName, int sleepMs, QSemaphore *semThreadReady, QSemaphore *semMainThreadDone)
 {
     QLockFile lockFile(fileName);
     if (!lockFile.lock()) {
@@ -233,7 +233,7 @@ void tst_QLockFile::waitForLock()
     QLockFile lockFile(fileName);
     QSemaphore semThreadReady, semMainThreadDone;
     // Lock file from a thread
-    QFuture<bool> ret = QtConcurrent::run<bool>(lockFromThread, fileName, threadSleepMs, &semThreadReady, &semMainThreadDone);
+    auto ret = QtConcurrent::run(lockFromThreadAndWait, fileName, threadSleepMs, &semThreadReady, &semMainThreadDone);
     semThreadReady.acquire();
 
     if (releaseEarly) // let the thread release the lock after threadSleepMs
@@ -410,7 +410,7 @@ void tst_QLockFile::staleLockRace()
     QThreadPool::globalInstance()->setMaxThreadCount(10);
     QFutureSynchronizer<QString> synchronizer;
     for (int i = 0; i < 8; ++i)
-        synchronizer.addFuture(QtConcurrent::run<QString>(tryStaleLockFromThread, fileName));
+        synchronizer.addFuture(QtConcurrent::run(tryStaleLockFromThread, fileName));
     synchronizer.waitForFinished();
     foreach (const QFuture<QString> &future, synchronizer.futures())
         QVERIFY2(future.result().isEmpty(), qPrintable(future.result()));
diff --git a/tests/auto/corelib/io/qurl/tst_qurl.cpp b/tests/auto/corelib/io/qurl/tst_qurl.cpp
index 8d046d5499..31d1de4234 100644
--- a/tests/auto/corelib/io/qurl/tst_qurl.cpp
+++ b/tests/auto/corelib/io/qurl/tst_qurl.cpp
@@ -4067,7 +4067,7 @@ void tst_QUrl::testThreading()
     QThreadPool::globalInstance()->setMaxThreadCount(100);
     QFutureSynchronizer<void> sync;
     for (int i = 0; i < 100; ++i)
-        sync.addFuture(QtConcurrent::run(this, &tst_QUrl::testThreadingHelper));
+        sync.addFuture(QtConcurrent::run(&tst_QUrl::testThreadingHelper, this));
     sync.waitForFinished();
     delete s_urlStorage;
 }
diff --git a/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp b/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp
index 7e3642752e..3c6da506e2 100644
--- a/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp
+++ b/tests/auto/corelib/mimetypes/qmimedatabase/tst_qmimedatabase.cpp
@@ -852,14 +852,14 @@ void tst_QMimeDatabase::fromThreads()
     QThreadPool tp;
     tp.setMaxThreadCount(20);
     // Note that data-based tests cannot be used here (QTest::fetchData asserts).
-    QtConcurrent::run(&tp, this, &tst_QMimeDatabase::mimeTypeForName);
-    QtConcurrent::run(&tp, this, &tst_QMimeDatabase::aliases);
-    QtConcurrent::run(&tp, this, &tst_QMimeDatabase::allMimeTypes);
-    QtConcurrent::run(&tp, this, &tst_QMimeDatabase::icons);
-    QtConcurrent::run(&tp, this, &tst_QMimeDatabase::inheritance);
-    QtConcurrent::run(&tp, this, &tst_QMimeDatabase::knownSuffix);
-    QtConcurrent::run(&tp, this, &tst_QMimeDatabase::mimeTypeForFileWithContent);
-    QtConcurrent::run(&tp, this, &tst_QMimeDatabase::allMimeTypes); // a second time
+    QtConcurrent::run(&tp, &tst_QMimeDatabase::mimeTypeForName, this);
+    QtConcurrent::run(&tp, &tst_QMimeDatabase::aliases, this);
+    QtConcurrent::run(&tp, &tst_QMimeDatabase::allMimeTypes, this);
+    QtConcurrent::run(&tp, &tst_QMimeDatabase::icons, this);
+    QtConcurrent::run(&tp, &tst_QMimeDatabase::inheritance, this);
+    QtConcurrent::run(&tp, &tst_QMimeDatabase::knownSuffix, this);
+    QtConcurrent::run(&tp, &tst_QMimeDatabase::mimeTypeForFileWithContent, this);
+    QtConcurrent::run(&tp, &tst_QMimeDatabase::allMimeTypes, this); // a second time
     QVERIFY(tp.waitForDone(60000));
 }