Async: initial support for native chaining of KJobs

It is now possible use KJob-derived jobs with libasync without having to write
lambda wrappers.

auto job = Async::start<ReturnType, MyKJob, MyKJob::result, Args ...)
           .then<ReturnType, OtherKJob, OtherKJob::result, PrevKJobReturnType>();

job.exec(arg1, arg2, ...);

The reason for this approach (instead of taking KJob* as an argument is that
we usually want the KJob ctor arguments to depend on result of previous job.
At least in case of Async::start() however it makes sense to support passing
KJob* as an argument (not yet implemented).

In future we should also support custom error handlers.

The KJob integration is build-time optional, but enabled by default (pass
-DWITH_KJOB=FALSE to CMake to disable).

Adds KCoreAddons dependency.

1 files changed, 46 insertions, 1 deletions

diff --git a/async/src/async.h b/async/src/async.h
index 2be1260..8da3daa 100644
--- a/async/src/async.h
+++ b/async/src/async.h
@@ -33,6 +33,11 @@
 
 #include <QDebug>
 
+#ifdef WITH_KJOB
+#include <KJob>
+#endif
+
+
 /*
  * TODO: instead of passing the future objects callbacks could be provided for result reporting (we can still use the future object internally
  */
@@ -196,10 +201,15 @@ Job<Out, In ...> start(ThenTask<Out, In ...> func);
 template<typename Out, typename ... In>
 Job<Out, In ...> start(SyncThenTask<Out, In ...> func);
 
+#ifdef WITH_KJOB
+template<typename ReturnType, typename KJobType, ReturnType (KJobType::*KJobResultMethod)(), typename ... Args>
+Job<ReturnType, Args ...> start();
+#endif
+
 
 /**
  * A null job.
- * 
+ *
  * An async noop.
  *
  */
@@ -283,6 +293,11 @@ class Job : public JobBase
     template<typename OutOther, typename ... InOther>
     friend Job<OutOther, InOther ...> start(Async::SyncThenTask<OutOther, InOther ...> func);
 
+#ifdef WITH_KJOB
+    template<typename ReturnType, typename KJobType, ReturnType (KJobType::*KJobResultMethod)(), typename ... Args>
+    friend Job<ReturnType, Args ...> start();
+#endif
+
 public:
     template<typename OutOther, typename ... InOther>
     Job<OutOther, InOther ...> then(ThenTask<OutOther, InOther ...> func, ErrorHandler errorFunc = ErrorHandler())
@@ -304,6 +319,14 @@ public:
         return then<OutOther, InOther ...>(nestedJobWrapper<OutOther, InOther ...>(otherJob), errorFunc);
     }
 
+#ifdef WITH_KJOB
+    template<typename ReturnType, typename KJobType, ReturnType (KJobType::*KJobResultMethod)(), typename ... Args>
+    Job<ReturnType, Args ...> then()
+    {
+        return start<ReturnType, KJobType, KJobResultMethod, Args ...>();
+    }
+#endif
+
     template<typename OutOther, typename InOther>
     Job<OutOther, InOther> each(EachTask<OutOther, InOther> func, ErrorHandler errorFunc = ErrorHandler())
     {
@@ -442,6 +465,28 @@ Job<Out, In ...> start(SyncThenTask<Out, In ...> func)
         new Private::SyncThenExecutor<Out, In ...>(func, ErrorHandler(), Private::ExecutorBasePtr())));
 }
 
+#ifdef WITH_KJOB
+template<typename ReturnType, typename KJobType, ReturnType (KJobType::*KJobResultMethod)(), typename ... Args>
+Job<ReturnType, Args ...> start()
+{
+    return Job<ReturnType, Args ...>(Private::ExecutorBasePtr(
+        new Private::ThenExecutor<ReturnType, Args ...>([](const Args & ... args, Async::Future<ReturnType> &future)
+            {
+                KJobType *job = new KJobType(args ...);
+                job->connect(job, &KJob::finished,
+                             [&future](KJob *job) {
+                                 if (job->error()) {
+                                     future.setError(job->error(), job->errorString());
+                                 } else {
+                                    future.setValue((static_cast<KJobType*>(job)->*KJobResultMethod)());
+                                    future.setFinished();
+                                 }
+                             });
+                job->start();
+            }, ErrorHandler(), Private::ExecutorBasePtr())));
+}
+#endif
+
 template<typename Out>
 Job<Out> null()
 {