Async: allow consumer continuation without arguments

It is now possible to chain a job that takes no arguments after a job
that returns void.

Unfortunatelly it is not yet possible to disregard return value of a
previous job.

2 files changed, 124 insertions, 8 deletions

diff --git a/async/autotests/asynctest.cpp b/async/autotests/asynctest.cpp
index 7437608..1074ff0 100644
--- a/async/autotests/asynctest.cpp
+++ b/async/autotests/asynctest.cpp
@@ -48,18 +48,20 @@ private Q_SLOTS:
     void testAsyncThen();
     void testSyncThen();
     void testJoinedThen();
+    void testVoidThen();
 
     void testAsyncEach();
     void testSyncEach();
     void testJoinedEach();
+    void testVoidEach();
 
     void testAsyncReduce();
     void testSyncReduce();
     void testJoinedReduce();
+    void testVoidReduce();
 
     void testErrorHandler();
 
-
     void testChainingRunningJob();
     void testChainingFinishedJob();
 
@@ -94,6 +96,30 @@ private:
 };
 
 
+template<>
+class AsyncTest::AsyncSimulator<void> {
+public:
+    AsyncSimulator(Async::Future<void> &future)
+        : mFuture(future)
+    {
+        QObject::connect(&mTimer, &QTimer::timeout,
+                            [this]() {
+                                mFuture.setFinished();
+                            });
+        QObject::connect(&mTimer, &QTimer::timeout,
+                            [this]() {
+                                delete this;
+                            });
+        mTimer.setSingleShot(true);
+        mTimer.start(200);
+    }
+
+private:
+    Async::Future<void> mFuture;
+    QTimer mTimer;
+};
+
+
 
 void AsyncTest::testSyncPromises()
 {
@@ -213,7 +239,8 @@ void AsyncTest::testSyncThen()
     auto job = Async::start<int>(
         []() -> int {
             return 42;
-        }).then<int, int>(
+        })
+    .then<int, int>(
         [](int in) -> int {
             return in * 2;
         });
@@ -243,6 +270,32 @@ void AsyncTest::testJoinedThen()
     QCOMPARE(future.value(), 84);
 }
 
+void AsyncTest::testVoidThen()
+{
+    int check = 0;
+
+    auto job = Async::start<void>(
+        [&check](Async::Future<void> &future) {
+            new AsyncSimulator<void>(future);
+            ++check;
+        })
+    .then<void>(
+        [&check](Async::Future<void> &future) {
+            new AsyncSimulator<void>(future);
+            ++check;
+        })
+    .then<void>(
+        [&check]() {
+            ++check;
+        });
+
+    auto future = job.exec();
+    future.waitForFinished();
+
+    QVERIFY(future.isFinished());
+    QCOMPARE(check, 3);
+}
+
 
 
 void AsyncTest::testAsyncEach()
@@ -303,6 +356,25 @@ void AsyncTest::testJoinedEach()
     QCOMPARE(future.value(), expected);
 }
 
+void AsyncTest::testVoidEach()
+{
+    QList<int> check;
+    auto job = Async::start<QList<int>>(
+        []() -> QList<int> {
+            return { 1, 2, 3, 4 };
+        }).each<void, int>(
+        [&check](const int &v) {
+            check << v;
+        });
+
+    auto future = job.exec();
+
+    const QList<int> expected({ 1, 2, 3, 4 });
+    QVERIFY(future.isFinished());
+    QCOMPARE(check, expected);
+}
+
+
 
 
 
@@ -377,6 +449,23 @@ void AsyncTest::testJoinedReduce()
     QCOMPARE(future.value(), 10);
 }
 
+void AsyncTest::testVoidReduce()
+{
+// This must not compile (reduce with void result makes no sense)
+#ifdef TEST_BUILD_FAIL
+    auto job = Async::start<QList<int>>(
+        []() -> QList<int> {
+            return { 1, 2, 3, 4 };
+        })
+    .reduce<void, QList<int>>(
+        [](const QList<int> &list) -> int {
+            return;
+        });
+
+    auto future = job.exec();
+    QVERIFY(future.isFinished());
+#endif
+}
 
 
 
@@ -471,8 +560,6 @@ void AsyncTest::testChainingFinishedJob()
 
 
 
-
-
 void AsyncTest::benchmarkSyncThenExecutor()
 {
     auto job = Async::start<int>(
diff --git a/async/src/async.h b/async/src/async.h
index 8296fbc..2be1260 100644
--- a/async/src/async.h
+++ b/async/src/async.h
@@ -150,7 +150,10 @@ class SyncThenExecutor : public Executor<typename detail::prevOut<In ...>::type,
 public:
     SyncThenExecutor(SyncThenTask<Out, In ...> then, ErrorHandler errorHandler, const ExecutorBasePtr &parent);
     void previousFutureReady();
+
 private:
+    void run(std::false_type); // !std::is_void<Out>
+    void run(std::true_type);  // std::is_void<Out>
     SyncThenTask<Out, In ...> mFunc;
 };
 
@@ -170,6 +173,8 @@ public:
     SyncEachExecutor(SyncEachTask<Out, In> each, ErrorHandler errorHandler, const ExecutorBasePtr &parent);
     void previousFutureReady();
 private:
+    void run(Async::Future<Out> *future, const typename PrevOut::value_type &arg, std::false_type); // !std::is_void<Out>
+    void run(Async::Future<Out> *future, const typename PrevOut::value_type &arg, std::true_type);  // std::is_void<Out>
     SyncEachTask<Out, In> mFunc;
 };
 
@@ -386,8 +391,8 @@ private:
     {
         static_assert(detail::isIterable<Out>::value,
                       "The 'Each' task can only be connected to a job that returns a list or an array.");
-        static_assert(detail::isIterable<OutOther>::value,
-                      "The result type of 'Each' task must be a list or an array.");
+        static_assert(std::is_void<OutOther>::value || detail::isIterable<OutOther>::value,
+                      "The result type of 'Each' task must be void, a list or an array.");
     }
 
     template<typename InOther>
@@ -603,9 +608,21 @@ void SyncThenExecutor<Out, In ...>::previousFutureReady()
         assert(this->mPrevFuture->isFinished());
     }
 
+    run(std::is_void<Out>());
+    this->mResult->setFinished();
+}
+
+template<typename Out, typename ... In>
+void SyncThenExecutor<Out, In ...>::run(std::false_type)
+{
     Out result = this->mFunc(this->mPrevFuture ? this->mPrevFuture->value() : In() ...);
     static_cast<Async::Future<Out>*>(this->mResult)->setValue(result);
-    this->mResult->setFinished();
+}
+
+template<typename Out, typename ... In>
+void SyncThenExecutor<Out, In ...>::run(std::true_type)
+{
+    this->mFunc(this->mPrevFuture ? this->mPrevFuture->value() : In() ...);
 }
 
 template<typename PrevOut, typename Out, typename In>
@@ -626,11 +643,23 @@ void SyncEachExecutor<PrevOut, Out, In>::previousFutureReady()
     }
 
     for (auto arg : this->mPrevFuture->value()) {
-        out->setValue(out->value() + this->mFunc(arg));
+        run(out, arg, std::is_void<Out>());
     }
     out->setFinished();
 }
 
+template<typename PrevOut, typename Out, typename In>
+void SyncEachExecutor<PrevOut, Out, In>::run(Async::Future<Out> *out, const typename PrevOut::value_type &arg, std::false_type)
+{
+    out->setValue(out->value() + this->mFunc(arg));
+}
+
+template<typename PrevOut, typename Out, typename In>
+void SyncEachExecutor<PrevOut, Out, In>::run(Async::Future<Out> * /* unushed */, const typename PrevOut::value_type &arg, std::true_type)
+{
+    this->mFunc(arg);
+}
+
 template<typename Out, typename In>
 SyncReduceExecutor<Out, In>::SyncReduceExecutor(SyncReduceTask<Out, In> reduce, ErrorHandler errorHandler, const ExecutorBasePtr &parent)
     : SyncThenExecutor<Out, In>(reduce, errorHandler, parent)