From 1aee1bda9fc81c888ad18fea107c271133dd5442 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dan=20Vr=C3=A1til?= <dvratil@redhat.com>
Date: Thu, 11 Dec 2014 14:22:27 +0100
Subject: Async: change syntax of callables

We now pass our own Async::Future to each task, instead of expecting tasks
to return their future. This allows us to re-use the same Future for repeated
invocations, like in the Each task.
---
 async/autotests/asynctest.cpp | 36 ++++++++++++++++++---------
 async/src/async.h             | 58 +++++++++++++++++++++++++++++--------------
 async/src/async_impl.h        | 21 +++++++++++++++-
 3 files changed, 83 insertions(+), 32 deletions(-)

(limited to 'async')

diff --git a/async/autotests/asynctest.cpp b/async/autotests/asynctest.cpp
index 786ff3c..19e40f7 100644
--- a/async/autotests/asynctest.cpp
+++ b/async/autotests/asynctest.cpp
@@ -40,28 +40,26 @@ public:
 private Q_SLOTS:
     void testSyncPromises();
     void testAsyncPromises();
+    void testSyncEach();
 };
 
 void AsyncTest::testSyncPromises()
 {
     auto baseJob = Async::start<int>(
-        []() -> Async::Future<int> {
-            auto f = Async::Future<int>(42);
+        [](Async::Future<int> &f) {
+            f.setValue(42);
             f.setFinished();
-            return f;
         })
     .then<QString, int>(
-        [](int v) -> Async::Future<QString> {
-            auto f = Async::Future<QString>("Result is " + QString::number(v));
+        [](int v, Async::Future<QString> &f) {
+            f.setValue("Result is " + QString::number(v));
             f.setFinished();
-            return f;
         });
 
     auto job = baseJob.then<QString, QString>(
-        [](const QString &v) -> Async::Future<QString> {
-            auto f = Async::Future<QString>(v.toUpper());
+        [](const QString &v, Async::Future<QString> &f) {
+            f.setValue(v.toUpper());
             f.setFinished();
-            return f;
         });
 
     job.exec();
@@ -73,8 +71,7 @@ void AsyncTest::testSyncPromises()
 void AsyncTest::testAsyncPromises()
 {
     auto job = Async::start<int>(
-      []() -> Async::Future<int> {
-          Async::Future<int> future(-1);
+      [](Async::Future<int> &future) {
           QTimer *timer = new QTimer();
           QObject::connect(timer, &QTimer::timeout,
                            [&]() {
@@ -85,7 +82,6 @@ void AsyncTest::testAsyncPromises()
                            timer, &QObject::deleteLater);
           timer->setSingleShot(true);
           timer->start(200);
-          return future;
       });
 
     job.exec();
@@ -93,6 +89,22 @@ void AsyncTest::testAsyncPromises()
     QCOMPARE(future.value(), 42);
 }
 
+void AsyncTest::testSyncEach()
+{
+  /*
+    auto job = Async::start<QList<int>>(
+        []() -> Async::Future<QList<int>> {
+            Async::Future<QList<int>> future(QList<int>{ 1, 2, 3, 4 });
+            future.setFinished();
+            return future;
+        })
+    .each<QList<int>, int>(
+        [](const int &v, Async::Future<QList<int>> &future) {
+            setFinished();
+        });
+        */
+}
+
 
 QTEST_MAIN(AsyncTest);
 
diff --git a/async/src/async.h b/async/src/async.h
index 239927d..182e57c 100644
--- a/async/src/async.h
+++ b/async/src/async.h
@@ -39,13 +39,20 @@ class JobBase;
 template<typename Out, typename ... In>
 class Job;
 
-template<typename Out, typename ... In, typename F>
-Job<Out, In ...> start(F func);
+template<typename Out, typename ... In>
+using ThenTask = typename detail::identity<std::function<void(In ..., Async::Future<Out>&)>>::type;
+template<typename Out, typename In>
+using EachTask = typename detail::identity<std::function<void(In, Async::Future<Out>&)>>::type;
+template<typename Out, typename In>
+using ReduceTask = typename detail::identity<std::function<void(In, Async::Future<Out>&)>>::type;
+
+template<typename Out, typename ... In>
+Job<Out, In ...> start(ThenTask<Out, In ...> func);
 
 namespace Private
 {
     template<typename Out, typename ... In>
-    Async::Future<Out>* doExec(Job<Out, In ...> *job, const In & ... args);
+    void doExec(Job<Out, In ...> *job, Async::Future<Out> &out, const In & ... args);
 }
 
 class JobBase
@@ -56,7 +63,8 @@ class JobBase
 protected:
     enum JobType {
         Then,
-        Each
+        Each,
+        Reduce
     };
 
 public:
@@ -75,8 +83,8 @@ class Job : public JobBase
     template<typename Out_, typename ... In_>
     friend class Job;
 
-    template<typename Out_, typename ... In_, typename F_>
-    friend Job<Out_, In_ ...> start(F_ func);
+    template<typename Out_, typename ... In_>
+    friend Job<Out_, In_ ...> start(Async::ThenTask<Out_, In_ ...> func);
 
     typedef Out OutType;
     typedef typename std::tuple_element<0, std::tuple<In ..., void>>::type InType;
@@ -87,16 +95,28 @@ public:
         delete reinterpret_cast<Async::Future<Out>*>(mResult);
     }
 
-    template<typename Out_, typename ... In_, typename F>
-    Job<Out_, In_ ...> then(F func)
+    template<typename Out_, typename ... In_>
+    Job<Out_, In_ ...> then(ThenTask<Out_, In_ ...> func)
     {
         return Job<Out_, In_ ...>::create(func, JobBase::Then, this);
     }
 
-    template<typename Out_, typename ... In_, typename F>
-    Job<Out_, In_ ...> each(F func)
+    template<typename Out_, typename In_>
+    Job<Out_, In_> each(EachTask<Out_, In_> func)
     {
-        return Job<Out_, In_ ...>::create(func, JobBase::Each, this);
+        static_assert(detail::isIterable<OutType>::value,
+                      "The 'Each' task can only be connected to a job that returns a list or array.");
+        static_assert(detail::isIterable<Out_>::value,
+                      "The result type of 'Each' task must be a list or an array.");
+        return Job<Out_, In_>::create(func, JobBase::Each, this);
+    }
+
+    template<typename Out_, typename In_>
+    Job<Out_, In_> reduce(ReduceTask<Out_, In_> func)
+    {
+        static_assert(Async::detail::isIterable<OutType>::value,
+                      "The result type of 'Reduce' task must be a list or an array.");
+        return Job<Out_, In_>::create(func, JobBase::Reduce, this);
     }
 
     Async::Future<Out> result() const
@@ -116,7 +136,7 @@ private:
     static Job<Out, In ... > create(F func, JobBase::JobType jobType, JobBase *parent = nullptr);
 
 public:
-    std::function<Async::Future<Out>(In ...)> mFunc;
+    std::function<void(In ..., Async::Future<Out>&)> mFunc;
 };
 
 
@@ -126,16 +146,16 @@ public:
 
 // ********** Out of line definitions ****************
 
-template<typename Out, typename ... In, typename F>
-Async::Job<Out, In ...> Async::start(F func)
+template<typename Out, typename ... In>
+Async::Job<Out, In ...> Async::start(ThenTask<Out, In ...> func)
 {
     return Job<Out, In ...>::create(func, JobBase::Then);
 }
 
 template<typename Out, typename ... In>
-Async::Future<Out>* Async::Private::doExec(Job<Out, In ...> *job, const In & ... args)
+void Async::Private::doExec(Job<Out, In ...> *job, Async::Future<Out> &out, const In & ... args)
 {
-    return new Async::Future<Out>(job->mFunc(args ...));
+    job->mFunc(args ..., out);
 };
 
 template<typename Out, typename ... In>
@@ -148,10 +168,10 @@ void Async::Job<Out, In ...>::exec()
         assert(in->isFinished());
     }
 
-    Job<Out, In ...> *job = dynamic_cast<Job<Out, In ...>*>(this);
-    Async::Future<Out> *out = Private::doExec<Out, In ...>(this, in ? in->value() : In() ...);
+    auto out = new Async::Future<Out>();
+    Private::doExec<Out, In ...>(this, *out, in ? in->value() : In() ...);
     out->waitForFinished();
-    job->mResult = reinterpret_cast<void*>(out);
+    mResult = reinterpret_cast<void*>(out);
 }
 
 template<typename Out, typename ... In>
diff --git a/async/src/async_impl.h b/async/src/async_impl.h
index 46bc25d..7b5c140 100644
--- a/async/src/async_impl.h
+++ b/async/src/async_impl.h
@@ -26,7 +26,26 @@
 
 namespace Async {
 
+namespace detail {
+
+template<typename T>
+struct identity
+{
+    typedef T type;
+};
+
+template<typename T, typename Enable = void>
+struct isIterable {
+    enum { value = 0 };
+};
+
+template<typename T>
+struct isIterable<T, typename std::conditional<false, typename T::iterator, void>::type> {
+    enum { value = 1 };
+};
+
+} // namespace Detail
 
 } // namespace Async
 
-#endif // ASYNC_IMPL_H
\ No newline at end of file
+#endif // ASYNC_IMPL_H
-- 
cgit v1.2.3