Async: introduce sync executors

Sync executors don't pass Async::Future into the user-provided tasks, but
instead work with return values of the task methods, wrapping them into the
Async::Future internally. Sync tasks are of course possible since forever, but
not the API for those tasks is much cleaner, for users don't have to deal with
"future" in synchronous tasks, for instance when synchronously processing results
of an async task before passing the data to another async task.

1 files changed, 127 insertions, 11 deletions

diff --git a/async/autotests/asynctest.cpp b/async/autotests/asynctest.cpp
index 9240d28..4ebe65e 100644
--- a/async/autotests/asynctest.cpp
+++ b/async/autotests/asynctest.cpp
@@ -42,9 +42,14 @@ private Q_SLOTS:
     void testAsyncPromises();
     void testAsyncPromises2();
     void testNestedAsync();
+    void testAsyncThen();
+    void testSyncThen();
+    void testAsyncEach();
     void testSyncEach();
+    void testAsyncReduce();
     void testSyncReduce();
     void testErrorHandler();
+
 };
 
 void AsyncTest::testSyncPromises()
@@ -155,17 +160,92 @@ void AsyncTest::testNestedAsync()
     QTRY_VERIFY(done);
 }
 
-void AsyncTest::testSyncEach()
+void AsyncTest::testAsyncThen()
+{
+    auto job = Async::start<int>(
+        [](Async::Future<int> &future) {
+            QTimer *timer = new QTimer;
+            QObject::connect(timer, &QTimer::timeout,
+                             [&]() {
+                                 future.setValue(42);
+                                 future.setFinished();
+                             });
+            QObject::connect(timer, &QTimer::timeout,
+                             timer, &QObject::deleteLater);
+            timer->setSingleShot(true);
+            timer->start(0);
+        });
+
+    auto future = job.exec();
+    future.waitForFinished();
+
+    QVERIFY(future.isFinished());
+    QCOMPARE(future.value(), 42);
+}
+
+
+void AsyncTest::testSyncThen()
+{
+    auto job = Async::start<int>(
+        []() -> int {
+            return 42;
+        }).then<int, int>(
+        [](int in) -> int {
+            return in * 2;
+        });
+
+    auto future = job.exec();
+    QVERIFY(future.isFinished());
+    QCOMPARE(future.value(), 84);
+}
+
+void AsyncTest::testAsyncEach()
 {
     auto job = Async::start<QList<int>>(
         [](Async::Future<QList<int>> &future) {
-            future.setValue(QList<int>{ 1, 2, 3, 4 });
-            future.setFinished();
+            QTimer *timer = new QTimer;
+            QObject::connect(timer, &QTimer::timeout,
+                             [&future]() {
+                                 future.setValue({ 1, 2, 3, 4 });
+                                 future.setFinished();
+                             });
+            QObject::connect(timer, &QTimer::timeout,
+                             timer, &QObject::deleteLater);
+            timer->setSingleShot(true);
+            timer->start(0);
         })
     .each<QList<int>, int>(
         [](const int &v, Async::Future<QList<int>> &future) {
-            future.setValue(QList<int>{ v + 1 });
-            future.setFinished();
+            QTimer *timer = new QTimer;
+            QObject::connect(timer, &QTimer::timeout,
+                             [v, &future]() {
+                                 future.setValue({ v + 1 });
+                                 future.setFinished();
+                             });
+            QObject::connect(timer, &QTimer::timeout,
+                             timer, &QObject::deleteLater);
+            timer->setSingleShot(true);
+            timer->start(0);
+        });
+
+    auto future = job.exec();
+    future.waitForFinished();
+
+    const QList<int> expected({ 2, 3, 4, 5 });
+    QVERIFY(future.isFinished());
+    QCOMPARE(future.value(), expected);
+}
+
+
+void AsyncTest::testSyncEach()
+{
+    auto job = Async::start<QList<int>>(
+        []() -> QList<int> {
+            return { 1, 2, 3, 4 };
+        })
+    .each<QList<int>, int>(
+        [](const int &v) -> QList<int> {
+            return { v + 1 };
         });
 
     Async::Future<QList<int>> future = job.exec();
@@ -175,19 +255,55 @@ void AsyncTest::testSyncEach()
     QCOMPARE(future.value(), expected);
 }
 
-void AsyncTest::testSyncReduce()
+void AsyncTest::testAsyncReduce()
 {
     auto job = Async::start<QList<int>>(
         [](Async::Future<QList<int>> &future) {
-            future.setValue(QList<int>{ 1, 2, 3, 4 });
-            future.setFinished();
+            QTimer *timer = new QTimer();
+            QObject::connect(timer, &QTimer::timeout,
+                             [&future]() {
+                                 future.setValue({ 1, 2, 3, 4 });
+                                 future.setFinished();
+                             });
+            QObject::connect(timer, &QTimer::timeout,
+                             timer, &QObject::deleteLater);
+            timer->setSingleShot(true);
+            timer->start(0);
         })
     .reduce<int, QList<int>>(
         [](const QList<int> &list, Async::Future<int> &future) {
+            QTimer *timer = new QTimer();
+            QObject::connect(timer, &QTimer::timeout,
+                             [list, &future]() {
+                                 int sum = 0;
+                                 for (int i : list) sum += i;
+                                 future.setValue(sum);
+                                 future.setFinished();
+                             });
+            QObject::connect(timer, &QTimer::timeout,
+                             timer, &QObject::deleteLater);
+            timer->setSingleShot(true);
+            timer->start(0);
+        });
+
+    Async::Future<int> future = job.exec();
+    future.waitForFinished();
+
+    QVERIFY(future.isFinished());
+    QCOMPARE(future.value(), 10);
+}
+
+void AsyncTest::testSyncReduce()
+{
+    auto job = Async::start<QList<int>>(
+        []() -> QList<int> {
+            return { 1, 2, 3, 4 };
+        })
+    .reduce<int, QList<int>>(
+        [](const QList<int> &list) -> int {
             int sum = 0;
             for (int i : list) sum += i;
-            future.setValue(sum);
-            future.setFinished();
+            return sum;
         });
 
     Async::Future<int> future = job.exec();
@@ -213,7 +329,7 @@ void AsyncTest::testErrorHandler()
     );
     auto future = job.exec();
     future.waitForFinished();
-    QVERIFY(error == 1);
+    QCOMPARE(error, 1);
     QVERIFY(future.isFinished());
 }