From 1da08ebfe267313015c201fd1106f891af554e14 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dan=20Vr=C3=A1til?= <dvratil@redhat.com>
Date: Fri, 20 Feb 2015 13:13:56 +0100
Subject: Async: allow Async::start() to have input value

The initial value can be passed in as argument to Job::exec(), or by another
job in case of job chaining.
---
 async/autotests/asynctest.cpp | 22 ++++++++++++++++
 async/src/async.h             | 58 ++++++++++++++++++++++++++++++++-----------
 2 files changed, 66 insertions(+), 14 deletions(-)

(limited to 'async')

diff --git a/async/autotests/asynctest.cpp b/async/autotests/asynctest.cpp
index 4ebe65e..ed550ca 100644
--- a/async/autotests/asynctest.cpp
+++ b/async/autotests/asynctest.cpp
@@ -25,6 +25,7 @@
 #include <QString>
 #include <QTimer>
 #include <QtTest/QTest>
+#include <QDebug>
 
 class AsyncTest : public QObject
 {
@@ -42,6 +43,8 @@ private Q_SLOTS:
     void testAsyncPromises();
     void testAsyncPromises2();
     void testNestedAsync();
+    void testStartValue();
+
     void testAsyncThen();
     void testSyncThen();
     void testAsyncEach();
@@ -52,6 +55,8 @@ private Q_SLOTS:
 
 };
 
+
+
 void AsyncTest::testSyncPromises()
 {
     auto baseJob = Async::start<int>(
@@ -160,6 +165,23 @@ void AsyncTest::testNestedAsync()
     QTRY_VERIFY(done);
 }
 
+void AsyncTest::testStartValue()
+{
+    auto job = Async::start<int, int>(
+        [](int in, Async::Future<int> &future) {
+            future.setValue(in);
+            future.setFinished();
+        });
+
+    auto future = job.exec(42);
+    QVERIFY(future.isFinished());
+    QCOMPARE(future.value(), 42);
+}
+
+
+
+
+
 void AsyncTest::testAsyncThen()
 {
     auto job = Async::start<int>(
diff --git a/async/src/async.h b/async/src/async.h
index 1f44f10..386722a 100644
--- a/async/src/async.h
+++ b/async/src/async.h
@@ -31,6 +31,7 @@
 #include <QObject>
 #include <QSharedPointer>
 
+#include <QDebug>
 
 /*
  * TODO: instead of passing the future objects callbacks could be provided for result reporting (we can still use the future object internally
@@ -44,6 +45,7 @@ class JobBase;
 
 template<typename Out, typename ... In>
 class Job;
+
 template<typename Out, typename ... In>
 using ThenTask = typename detail::identity<std::function<void(In ..., Async::Future<Out>&)>>::type;
 template<typename Out, typename ... In>
@@ -71,6 +73,9 @@ class ExecutorBase
     template<typename PrevOut, typename Out, typename ... In>
     friend class Executor;
 
+    template<typename Out, typename ... In>
+    friend class Async::Job;
+
 public:
     virtual ~ExecutorBase();
     virtual void exec() = 0;
@@ -178,8 +183,11 @@ private:
  *             void return type, and accept exactly one argument of type @p Async::Future<In>,
  *             where @p In is type of the result.
  */
-template<typename Out>
-Job<Out> start(ThenTask<Out> func);
+template<typename Out, typename ... In>
+Job<Out, In ...> start(ThenTask<Out, In ...> func);
+
+template<typename Out, typename ... In>
+Job<Out, In ...> start(SyncThenTask<Out, In ...> func);
 
 
 /**
@@ -262,11 +270,11 @@ class Job : public JobBase
     template<typename OutOther, typename ... InOther>
     friend class Job;
 
-    template<typename OutOther>
-    friend Job<OutOther> start(Async::ThenTask<OutOther> func);
+    template<typename OutOther, typename ... InOther>
+    friend Job<OutOther, InOther ...> start(Async::ThenTask<OutOther, InOther ...> func);
 
-    template<typename OutOther>
-    friend Job<OutOther> start(Async::SyncThenTask<OutOther> func);
+    template<typename OutOther, typename ... InOther>
+    friend Job<OutOther, InOther ...> start(Async::SyncThenTask<OutOther, InOther ...> func);
 
 public:
     template<typename OutOther, typename ... InOther>
@@ -315,6 +323,27 @@ public:
             new Private::SyncReduceExecutor<OutOther, InOther>(func, errorFunc, mExecutor)));
     }
 
+    template<typename FirstIn>
+    Async::Future<Out> exec(FirstIn in)
+    {
+        // Inject a fake sync executor that will return the initial value
+        Private::ExecutorBasePtr first = mExecutor;
+        while (first->mPrev) {
+            first = first->mPrev;
+        }
+        auto init = new Private::SyncThenExecutor<FirstIn>(
+            [in]() -> FirstIn {
+                return in;
+            },
+            ErrorHandler(), Private::ExecutorBasePtr());
+        first->mPrev = Private::ExecutorBasePtr(init);
+
+        auto result = exec();
+        // Remove the injected executor
+        first->mPrev.reset();
+        return result;
+    }
+
     Async::Future<Out> exec()
     {
         mExecutor->exec();
@@ -357,18 +386,18 @@ private:
 
 namespace Async {
 
-template<typename Out>
-Job<Out> start(ThenTask<Out> func)
+template<typename Out, typename ... In>
+Job<Out, In ...> start(ThenTask<Out, In ...> func)
 {
-    return Job<Out>(Private::ExecutorBasePtr(
-        new Private::ThenExecutor<Out>(func, ErrorHandler(), Private::ExecutorBasePtr())));
+    return Job<Out, In...>(Private::ExecutorBasePtr(
+        new Private::ThenExecutor<Out, In ...>(func, ErrorHandler(), Private::ExecutorBasePtr())));
 }
 
-template<typename Out>
-Job<Out> start(SyncThenTask<Out> func)
+template<typename Out, typename ... In>
+Job<Out, In ...> start(SyncThenTask<Out, In ...> func)
 {
-    return Job<Out>(Private::ExecutorBasePtr(
-        new Private::SyncThenExecutor<Out>(func, ErrorHandler(), Private::ExecutorBasePtr())));
+    return Job<Out, In...>(Private::ExecutorBasePtr(
+        new Private::SyncThenExecutor<Out, In ...>(func, ErrorHandler(), Private::ExecutorBasePtr())));
 }
 
 template<typename Out>
@@ -443,6 +472,7 @@ void Executor<PrevOut, Out, In ...>::exec()
     }
 }
 
+
 template<typename Out, typename ... In>
 ThenExecutor<Out, In ...>::ThenExecutor(ThenTask<Out, In ...> then, ErrorHandler error, const ExecutorBasePtr &parent)
     : Executor<typename detail::prevOut<In ...>::type, Out, In ...>(error, parent)
-- 
cgit v1.2.3