7 files changed, 497 insertions, 190 deletions

diff --git a/async/src/CMakeLists.txt b/async/src/CMakeLists.txt
index 6f8ab63..becc8ee 100644
--- a/async/src/CMakeLists.txt
+++ b/async/src/CMakeLists.txt
@@ -5,6 +5,7 @@ include_directories(${CMAKE_CURRENT_BINARY_DIR})
 set(async_SRCS
     async.cpp
     future.cpp
+    debug.cpp
 )
 
 add_library(${PROJECT_NAME} SHARED ${async_SRCS})
diff --git a/async/src/async.cpp b/async/src/async.cpp
index 5e26bd8..e92d333 100644
--- a/async/src/async.cpp
+++ b/async/src/async.cpp
@@ -21,9 +21,57 @@
 #include <QDebug>
 #include <QEventLoop>
 
-
 using namespace Async;
 
+Private::Execution::Execution(const Private::ExecutorBasePtr &executor)
+    : executor(executor)
+    , resultBase(nullptr)
+    , isRunning(false)
+    , isFinished(false)
+{
+}
+
+Private::Execution::~Execution()
+{
+    if (resultBase) {
+        resultBase->releaseExecution();
+        delete resultBase;
+    }
+    prevExecution.reset();
+}
+
+void Private::Execution::setFinished()
+{
+    isFinished = true;
+    //executor.clear();
+#ifndef QT_NO_DEBUG
+    if (tracer) {
+        delete tracer;
+    }
+#endif
+}
+
+void Private::Execution::releaseFuture()
+{
+    resultBase = 0;
+}
+
+bool Private::Execution::errorWasHandled() const
+{
+    Execution *exec = const_cast<Execution*>(this);
+    while (exec) {
+        if (exec->executor->hasErrorFunc()) {
+            return true;
+        }
+        exec = exec->prevExecution.data();
+    }
+    return false;
+}
+
+
+
+
+
 Private::ExecutorBase::ExecutorBase(const ExecutorBasePtr &parent)
     : mPrev(parent)
 {
@@ -34,6 +82,8 @@ Private::ExecutorBase::~ExecutorBase()
 }
 
 
+
+
 JobBase::JobBase(const Private::ExecutorBasePtr &executor)
     : mExecutor(executor)
 {
diff --git a/async/src/async.h b/async/src/async.h
index c6ca9e7..73eeaa0 100644
--- a/async/src/async.h
+++ b/async/src/async.h
@@ -25,6 +25,7 @@
 #include <iterator>
 
 #include "future.h"
+#include "debug.h"
 #include "async_impl.h"
 
 #include <QVector>
@@ -46,20 +47,22 @@
  * that can be stored and executed later on. Jobs can be composed, similarly to functions.
  *
  * Relations between the components:
- * * Job: description of what should happen
- * * Executor: Running execution of a job, the process that calculates the result.
+ * * Job: API wrapper around Executors chain. Can be destroyed while still running,
+ *        because the actual execution happens in the background
+ * * Executor: Describes task to execute. Executors form a linked list matching the
+ *        order in which they will be executed. The Executor chain is destroyed when
+ *        the parent Job is destroyed. However if the Job is still running it is
+ *        guaranteed that the Executor chain will not be destroyed until the execution
+ *        is finished.
+ * * Execution: The running execution of the task stored in Executor. Each call to Job::exec()
+ *        instantiates new Execution chain, which makes it possible for the Job to be
+ *        executed multiple times (even in parallel).
  * * Future: Representation of the result that is being calculated
  *
- * Lifetime:
- * * Before a job is executed is treated like a normal value on the stack.
- * * As soon as the job is executed, a heap allocated executor keeps the task running until complete. The associated future handle remains
- *   valid until the task is complete. To abort a job it has to be killed through the future handle.
- *   TODO: Can we tie the lifetime of the executor to the last available future handle?
  *
- * TODO: Progress reporting through future
+ * TODO: Composed progress reporting
  * TODO: Possibility to abort a job through future (perhaps optional?)
  * TODO: Support for timeout, specified during exec call, after which the error handler gets called with a defined errorCode.
- * TODO: Repeated execution of a job to facilitate i.e. an async while loop of a job?
  */
 namespace Async {
 
@@ -94,38 +97,18 @@ class ExecutorBase;
 typedef QSharedPointer<ExecutorBase> ExecutorBasePtr;
 
 struct Execution {
-    Execution(const ExecutorBasePtr &executor)
-        : executor(executor)
-        , resultBase(nullptr)
-        , isRunning(false)
-        , isFinished(false)
-    {}
-
-    ~Execution()
-    {
-        if (resultBase) {
-            resultBase->releaseExecution();
-            delete resultBase;
-        }
-        prevExecution.reset();
-    }
-
-    void setFinished()
-    {
-        isFinished = true;
-        executor.clear();
-    }
+    Execution(const ExecutorBasePtr &executor);
+    ~Execution();
+    void setFinished();
 
     template<typename T>
-    Async::Future<T>* result()
+    Async::Future<T>* result() const
     {
         return static_cast<Async::Future<T>*>(resultBase);
     }
 
-    void releaseFuture()
-    {
-        resultBase = 0;
-    }
+    void releaseFuture();
+    bool errorWasHandled() const;
 
     ExecutorBasePtr executor;
     FutureBase *resultBase;
@@ -133,8 +116,13 @@ struct Execution {
     bool isFinished;
 
     ExecutionPtr prevExecution;
+
+#ifndef QT_NO_DEBUG
+    Tracer *tracer;
+#endif
 };
 
+
 typedef QSharedPointer<Execution> ExecutionPtr;
 
 class ExecutorBase
@@ -145,6 +133,9 @@ class ExecutorBase
     template<typename Out, typename ... In>
     friend class Async::Job;
 
+    friend class Execution;
+    friend class Async::Tracer;
+
 public:
     virtual ~ExecutorBase();
     virtual ExecutionPtr exec(const ExecutorBasePtr &self) = 0;
@@ -155,21 +146,31 @@ protected:
     template<typename T>
     Async::Future<T>* createFuture(const ExecutionPtr &execution) const;
 
+    virtual bool hasErrorFunc() const = 0;
+    virtual bool handleError(const ExecutionPtr &execution) = 0;
+
     ExecutorBasePtr mPrev;
+
+#ifndef QT_NO_DEBUG
+    QString mExecutorName;
+#endif
 };
 
 template<typename PrevOut, typename Out, typename ... In>
 class Executor : public ExecutorBase
 {
 protected:
-    Executor(ErrorHandler errorHandler, const Private::ExecutorBasePtr &parent)
+    Executor(ErrorHandler errorFunc, const Private::ExecutorBasePtr &parent)
         : ExecutorBase(parent)
-        , mErrorFunc(errorHandler)
+        , mErrorFunc(errorFunc)
     {}
+
     virtual ~Executor() {}
     virtual void run(const ExecutionPtr &execution) = 0;
 
     ExecutionPtr exec(const ExecutorBasePtr &self);
+    bool hasErrorFunc() const { return (bool) mErrorFunc; }
+    bool handleError(const ExecutionPtr &execution);
 
     std::function<void(int, const QString &)> mErrorFunc;
 };
@@ -178,7 +179,7 @@ template<typename Out, typename ... In>
 class ThenExecutor: public Executor<typename detail::prevOut<In ...>::type, Out, In ...>
 {
 public:
-    ThenExecutor(ThenTask<Out, In ...> then, ErrorHandler errorHandler, const ExecutorBasePtr &parent);
+    ThenExecutor(ThenTask<Out, In ...> then, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
     void run(const ExecutionPtr &execution);
 private:
     ThenTask<Out, In ...> mFunc;
@@ -188,7 +189,7 @@ template<typename PrevOut, typename Out, typename In>
 class EachExecutor : public Executor<PrevOut, Out, In>
 {
 public:
-    EachExecutor(EachTask<Out, In> each, ErrorHandler errorHandler, const ExecutorBasePtr &parent);
+    EachExecutor(EachTask<Out, In> each, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
     void run(const ExecutionPtr &execution);
 private:
     EachTask<Out, In> mFunc;
@@ -199,7 +200,7 @@ template<typename Out, typename In>
 class ReduceExecutor : public ThenExecutor<Out, In>
 {
 public:
-    ReduceExecutor(ReduceTask<Out, In> reduce, ErrorHandler errorHandler, const ExecutorBasePtr &parent);
+    ReduceExecutor(ReduceTask<Out, In> reduce, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
 private:
     ReduceTask<Out, In> mFunc;
 };
@@ -208,7 +209,7 @@ template<typename Out, typename ... In>
 class SyncThenExecutor : public Executor<typename detail::prevOut<In ...>::type, Out, In ...>
 {
 public:
-    SyncThenExecutor(SyncThenTask<Out, In ...> then, ErrorHandler errorHandler, const ExecutorBasePtr &parent);
+    SyncThenExecutor(SyncThenTask<Out, In ...> then, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
     void run(const ExecutionPtr &execution);
 
 private:
@@ -221,7 +222,7 @@ template<typename Out, typename In>
 class SyncReduceExecutor : public SyncThenExecutor<Out, In>
 {
 public:
-    SyncReduceExecutor(SyncReduceTask<Out, In> reduce, ErrorHandler errorHandler, const ExecutorBasePtr &parent);
+    SyncReduceExecutor(SyncReduceTask<Out, In> reduce, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
 private:
     SyncReduceTask<Out, In> mFunc;
 };
@@ -230,7 +231,7 @@ template<typename PrevOut, typename Out, typename In>
 class SyncEachExecutor : public Executor<PrevOut, Out, In>
 {
 public:
-    SyncEachExecutor(SyncEachTask<Out, In> each, ErrorHandler errorHandler, const ExecutorBasePtr &parent);
+    SyncEachExecutor(SyncEachTask<Out, In> each, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
     void run(const ExecutionPtr &execution);
 private:
     void run(Async::Future<Out> *future, const typename PrevOut::value_type &arg, std::false_type); // !std::is_void<Out>
@@ -251,10 +252,10 @@ private:
  *             where @p In is type of the result.
  */
 template<typename Out, typename ... In>
-Job<Out, In ...> start(ThenTask<Out, In ...> func);
+Job<Out, In ...> start(ThenTask<Out, In ...> func, ErrorHandler errorFunc = ErrorHandler());
 
 template<typename Out, typename ... In>
-Job<Out, In ...> start(SyncThenTask<Out, In ...> func);
+Job<Out, In ...> start(SyncThenTask<Out, In ...> func, ErrorHandler errorFunc = ErrorHandler());
 
 #ifdef WITH_KJOB
 template<typename ReturnType, typename KJobType, ReturnType (KJobType::*KJobResultMethod)(), typename ... Args>
@@ -356,10 +357,10 @@ class Job : public JobBase
     friend class Job;
 
     template<typename OutOther, typename ... InOther>
-    friend Job<OutOther, InOther ...> start(Async::ThenTask<OutOther, InOther ...> func);
+    friend Job<OutOther, InOther ...> start(Async::ThenTask<OutOther, InOther ...> func, ErrorHandler errorFunc);
 
     template<typename OutOther, typename ... InOther>
-    friend Job<OutOther, InOther ...> start(Async::SyncThenTask<OutOther, InOther ...> func);
+    friend Job<OutOther, InOther ...> start(Async::SyncThenTask<OutOther, InOther ...> func, ErrorHandler errorFunc);
 
 #ifdef WITH_KJOB
     template<typename ReturnType, typename KJobType, ReturnType (KJobType::*KJobResultMethod)(), typename ... Args>
@@ -499,9 +500,14 @@ private:
             auto job = otherJob;
             FutureWatcher<OutOther> *watcher = new FutureWatcher<OutOther>();
             QObject::connect(watcher, &FutureWatcherBase::futureReady,
-                             [watcher, &future]() {
-                                 Async::detail::copyFutureValue(watcher->future(), future);
-                                 future.setFinished();
+                             [watcher, future]() {
+                                 // FIXME: We pass future by value, because using reference causes the
+                                 // future to get deleted before this lambda is invoked, leading to crash
+                                 // in copyFutureValue()
+                                 // copy by value is const
+                                 auto outFuture = future;
+                                 Async::detail::copyFutureValue(watcher->future(), outFuture);
+                                 outFuture.setFinished();
                                  delete watcher;
                              });
             watcher->setFuture(job.exec(in ...));
@@ -517,17 +523,17 @@ private:
 namespace Async {
 
 template<typename Out, typename ... In>
-Job<Out, In ...> start(ThenTask<Out, In ...> func)
+Job<Out, In ...> start(ThenTask<Out, In ...> func, ErrorHandler error)
 {
     return Job<Out, In...>(Private::ExecutorBasePtr(
-        new Private::ThenExecutor<Out, In ...>(func, ErrorHandler(), Private::ExecutorBasePtr())));
+        new Private::ThenExecutor<Out, In ...>(func, error, Private::ExecutorBasePtr())));
 }
 
 template<typename Out, typename ... In>
-Job<Out, In ...> start(SyncThenTask<Out, In ...> func)
+Job<Out, In ...> start(SyncThenTask<Out, In ...> func, ErrorHandler error)
 {
     return Job<Out, In...>(Private::ExecutorBasePtr(
-        new Private::SyncThenExecutor<Out, In ...>(func, ErrorHandler(), Private::ExecutorBasePtr())));
+        new Private::SyncThenExecutor<Out, In ...>(func, error, Private::ExecutorBasePtr())));
 }
 
 #ifdef WITH_KJOB
@@ -586,20 +592,18 @@ ExecutionPtr Executor<PrevOut, Out, In ...>::exec(const ExecutorBasePtr &self)
     // Passing 'self' to execution ensures that the Executor chain remains
     // valid until the entire execution is finished
     ExecutionPtr execution = ExecutionPtr::create(self);
+#ifndef QT_NO_DEBUG
+    execution->tracer = new Tracer(execution.data()); // owned by execution
+#endif
 
     // chainup
     execution->prevExecution = mPrev ? mPrev->exec(mPrev) : ExecutionPtr();
-    /*
-    } else if (mPrev && !mPrevFuture) {
-        // If previous job is running or finished, just get it's future
-        mPrevFuture = static_cast<Async::Future<PrevOut>*>(mPrev->result());
-    }
-    */
 
-    execution->resultBase = this->createFuture<Out>(execution);
+    execution->resultBase = ExecutorBase::createFuture<Out>(execution);
     auto fw = new Async::FutureWatcher<Out>();
     QObject::connect(fw, &Async::FutureWatcher<Out>::futureReady,
                      [fw, execution, this]() {
+                         handleError(execution);
                          execution->setFinished();
                          delete fw;
                      });
@@ -607,50 +611,77 @@ ExecutionPtr Executor<PrevOut, Out, In ...>::exec(const ExecutorBasePtr &self)
 
     Async::Future<PrevOut> *prevFuture = execution->prevExecution ? execution->prevExecution->result<PrevOut>() : nullptr;
     if (!prevFuture || prevFuture->isFinished()) {
-        if (prevFuture && prevFuture->errorCode() != 0) {
-            if (mErrorFunc) {
-                mErrorFunc(prevFuture->errorCode(), prevFuture->errorMessage());
-                execution->resultBase->setFinished();
-                execution->setFinished();
-                return execution;
+        if (prevFuture) { // prevFuture implies execution->prevExecution
+            if (prevFuture->errorCode()) {
+                // Propagate the errorCode and message to the outer Future
+                execution->resultBase->setError(prevFuture->errorCode(), prevFuture->errorMessage());
+                if (!execution->errorWasHandled()) {
+                    if (handleError(execution)) {
+                        return execution;
+                    }
+                } else {
+                    return execution;
+                }
             } else {
-                // Propagate the error to next caller
+                // Propagate error (if any)
             }
         }
+
         execution->isRunning = true;
         run(execution);
     } else {
-        auto futureWatcher = new Async::FutureWatcher<PrevOut>();
-        QObject::connect(futureWatcher, &Async::FutureWatcher<PrevOut>::futureReady,
-                         [futureWatcher, execution, this]() {
-                             auto prevFuture = futureWatcher->future();
+        auto prevFutureWatcher = new Async::FutureWatcher<PrevOut>();
+        QObject::connect(prevFutureWatcher, &Async::FutureWatcher<PrevOut>::futureReady,
+                         [prevFutureWatcher, execution, this]() {
+                             auto prevFuture = prevFutureWatcher->future();
                              assert(prevFuture.isFinished());
-                             delete futureWatcher;
-                             if (prevFuture.errorCode() != 0) {
-                                 if (mErrorFunc) {
-                                     mErrorFunc(prevFuture.errorCode(), prevFuture.errorMessage());
-                                     execution->resultBase->setFinished();
-                                     return;
+                             delete prevFutureWatcher;
+                             auto prevExecutor = execution->executor->mPrev;
+                             if (prevFuture.errorCode()) {
+                                 execution->resultBase->setError(prevFuture.errorCode(), prevFuture.errorMessage());
+                                 if (!execution->errorWasHandled()) {
+                                    if (handleError(execution)) {
+                                        return;
+                                    }
                                  } else {
-                                     // Propagate the error to next caller
+                                     return;
                                  }
                              }
+
+
+                             // propagate error (if any)
                              execution->isRunning = true;
                              run(execution);
                          });
 
-        futureWatcher->setFuture(*static_cast<Async::Future<PrevOut>*>(prevFuture));
+        prevFutureWatcher->setFuture(*static_cast<Async::Future<PrevOut>*>(prevFuture));
     }
 
     return execution;
 }
 
+template<typename PrevOut, typename Out, typename ... In>
+bool Executor<PrevOut, Out, In ...>::handleError(const ExecutionPtr &execution)
+{
+    assert(execution->resultBase->isFinished());
+    if (execution->resultBase->errorCode()) {
+        if (mErrorFunc) {
+            mErrorFunc(execution->resultBase->errorCode(),
+                       execution->resultBase->errorMessage());
+            return true;
+        }
+    }
+
+    return false;
+}
+
 
 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)
     , mFunc(then)
 {
+    STORE_EXECUTOR_NAME("ThenExecutor", Out, In ...);
 }
 
 template<typename Out, typename ... In>
@@ -662,7 +693,7 @@ void ThenExecutor<Out, In ...>::run(const ExecutionPtr &execution)
         assert(prevFuture->isFinished());
     }
 
-    this->mFunc(prevFuture ? prevFuture->value() : In() ..., *execution->result<Out>());
+    ThenExecutor<Out, In ...>::mFunc(prevFuture ? prevFuture->value() : In() ..., *execution->result<Out>());
 }
 
 template<typename PrevOut, typename Out, typename In>
@@ -670,6 +701,7 @@ EachExecutor<PrevOut, Out, In>::EachExecutor(EachTask<Out, In> each, ErrorHandle
     : Executor<PrevOut, Out, In>(error, parent)
     , mFunc(each)
 {
+    STORE_EXECUTOR_NAME("EachExecutor", PrevOut, Out, In);
 }
 
 template<typename PrevOut, typename Out, typename In>
@@ -687,7 +719,7 @@ void EachExecutor<PrevOut, Out, In>::run(const ExecutionPtr &execution)
 
     for (auto arg : prevFuture->value()) {
         Async::Future<Out> future;
-        this->mFunc(arg, future);
+        EachExecutor<PrevOut, Out, In>::mFunc(arg, future);
         auto fw = new Async::FutureWatcher<Out>();
         mFutureWatchers.append(fw);
         QObject::connect(fw, &Async::FutureWatcher<Out>::futureReady,
@@ -708,16 +740,18 @@ void EachExecutor<PrevOut, Out, In>::run(const ExecutionPtr &execution)
 }
 
 template<typename Out, typename In>
-ReduceExecutor<Out, In>::ReduceExecutor(ReduceTask<Out, In> reduce, ErrorHandler error, const ExecutorBasePtr &parent)
-    : ThenExecutor<Out, In>(reduce, error, parent)
+ReduceExecutor<Out, In>::ReduceExecutor(ReduceTask<Out, In> reduce, ErrorHandler errorFunc, const ExecutorBasePtr &parent)
+    : ThenExecutor<Out, In>(reduce, errorFunc, parent)
 {
+    STORE_EXECUTOR_NAME("ReduceExecutor", Out, In);
 }
 
 template<typename Out, typename ... In>
-SyncThenExecutor<Out, In ...>::SyncThenExecutor(SyncThenTask<Out, In ...> then, ErrorHandler errorHandler, const ExecutorBasePtr &parent)
-    : Executor<typename detail::prevOut<In ...>::type, Out, In ...>(errorHandler, parent)
+SyncThenExecutor<Out, In ...>::SyncThenExecutor(SyncThenTask<Out, In ...> then, ErrorHandler errorFunc, const ExecutorBasePtr &parent)
+    : Executor<typename detail::prevOut<In ...>::type, Out, In ...>(errorFunc, parent)
     , mFunc(then)
 {
+    STORE_EXECUTOR_NAME("SyncThenExecutor", Out, In ...);
 }
 
 template<typename Out, typename ... In>
@@ -740,7 +774,7 @@ void SyncThenExecutor<Out, In ...>::run(const ExecutionPtr &execution, std::fals
             : nullptr;
     (void) prevFuture; // silence 'set but not used' warning
     Async::Future<Out> *future = execution->result<Out>();
-    future->setValue(this->mFunc(prevFuture ? prevFuture->value() : In() ...));
+    future->setValue(SyncThenExecutor<Out, In...>::mFunc(prevFuture ? prevFuture->value() : In() ...));
 }
 
 template<typename Out, typename ... In>
@@ -751,14 +785,15 @@ void SyncThenExecutor<Out, In ...>::run(const ExecutionPtr &execution, std::true
             ? execution->prevExecution->result<typename detail::prevOut<In ...>::type>()
             : nullptr;
     (void) prevFuture; // silence 'set but not used' warning
-    this->mFunc(prevFuture ? prevFuture->value() : In() ...);
+    SyncThenExecutor<Out, In ...>::mFunc(prevFuture ? prevFuture->value() : In() ...);
 }
 
 template<typename PrevOut, typename Out, typename In>
-SyncEachExecutor<PrevOut, Out, In>::SyncEachExecutor(SyncEachTask<Out, In> each, ErrorHandler errorHandler, const ExecutorBasePtr &parent)
-    : Executor<PrevOut, Out, In>(errorHandler, parent)
+SyncEachExecutor<PrevOut, Out, In>::SyncEachExecutor(SyncEachTask<Out, In> each, ErrorHandler errorFunc, const ExecutorBasePtr &parent)
+    : Executor<PrevOut, Out, In>(errorFunc, parent)
     , mFunc(each)
 {
+    STORE_EXECUTOR_NAME("SyncEachExecutor", PrevOut, Out, In);
 }
 
 template<typename PrevOut, typename Out, typename In>
@@ -783,19 +818,20 @@ void SyncEachExecutor<PrevOut, Out, In>::run(const ExecutionPtr &execution)
 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));
+    out->setValue(out->value() + SyncEachExecutor<PrevOut, Out, In>::mFunc(arg));
 }
 
 template<typename PrevOut, typename Out, typename In>
 void SyncEachExecutor<PrevOut, Out, In>::run(Async::Future<Out> * /* unused */, const typename PrevOut::value_type &arg, std::true_type)
 {
-    this->mFunc(arg);
+    SyncEachExecutor<PrevOut, Out, In>::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)
+SyncReduceExecutor<Out, In>::SyncReduceExecutor(SyncReduceTask<Out, In> reduce, ErrorHandler errorFunc, const ExecutorBasePtr &parent)
+    : SyncThenExecutor<Out, In>(reduce, errorFunc, parent)
 {
+    STORE_EXECUTOR_NAME("SyncReduceExecutor", Out, In);
 }
 
 
diff --git a/async/src/debug.cpp b/async/src/debug.cpp
new file mode 100644
index 0000000..9dfad1a
--- /dev/null
+++ b/async/src/debug.cpp
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2015  Daniel Vrátil <dvratil@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "debug.h"
+#include "async.h"
+
+#include <QStringBuilder>
+
+#ifdef __GNUG__
+#include <cxxabi.h>
+#include <memory>
+#endif
+
+namespace Async
+{
+
+Q_LOGGING_CATEGORY(Debug, "org.kde.async", QtWarningMsg);
+Q_LOGGING_CATEGORY(Trace, "org.kde.async.trace", QtWarningMsg);
+
+QString demangleName(const char *name)
+{
+#ifdef __GNUG__
+    int status = 1; // uses -3 to 0 error codes
+    std::unique_ptr<char, void(*)(void*)> demangled(abi::__cxa_demangle(name, 0, 0, &status), std::free);
+    if (status == 0) {
+        return QString(demangled.get());
+    }
+#endif
+    return QString(name);
+}
+
+}
+
+using namespace Async;
+
+int Tracer::lastId = 0;
+
+Tracer::Tracer(Private::Execution *execution)
+    : mId(lastId++)
+    , mExecution(execution)
+{
+    msg(Async::Tracer::Start);
+}
+
+Tracer::~Tracer()
+{
+    msg(Async::Tracer::End);
+    // FIXME: Does this work on parallel executions?
+    --lastId;
+    --mId;
+}
+
+void Tracer::msg(Tracer::MsgType msgType)
+{
+    qCDebug(Trace).nospace() << (QString().fill(QLatin1Char(' '), mId * 2) % 
+                                 (msgType == Async::Tracer::Start ? " START " : " END   ") %
+                                 QString::number(mId) % " " %
+                                 mExecution->executor->mExecutorName);
+}
diff --git a/async/src/debug.h b/async/src/debug.h
new file mode 100644
index 0000000..c453eb3
--- /dev/null
+++ b/async/src/debug.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2015  Daniel Vrátil <dvratil@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef ASYNC_DEBUG_H
+#define ASYNC_DEBUG_H
+
+#include <QLoggingCategory>
+#include <QStringBuilder>
+
+#ifndef QT_NO_DEBUG
+#include <typeinfo>
+#endif
+
+namespace Async
+{
+
+Q_DECLARE_LOGGING_CATEGORY(Debug)
+Q_DECLARE_LOGGING_CATEGORY(Trace)
+
+QString demangleName(const char *name);
+
+namespace Private
+{
+class Execution;
+}
+
+class Tracer
+{
+public:
+    Tracer(Private::Execution *execution);
+    ~Tracer();
+
+private:
+    enum MsgType {
+        Start,
+        End
+    };
+    void msg(MsgType);
+
+    int mId;
+    Private::Execution *mExecution;
+
+    static int lastId;
+};
+
+}
+
+#ifndef QT_NO_DEBUG
+    template<typename T>
+    QString storeExecutorNameExpanded() {
+        return Async::demangleName(typeid(T).name());
+    }
+
+    template<typename T, typename ... Tail>
+    typename std::enable_if<sizeof ... (Tail) != 0, QString>::type
+    storeExecutorNameExpanded() {
+        return storeExecutorNameExpanded<T>() % QStringLiteral(", ") % storeExecutorNameExpanded<Tail ...>();
+    }
+
+    #define STORE_EXECUTOR_NAME(name, ...) \
+        ExecutorBase::mExecutorName = QStringLiteral(name) % QStringLiteral("<") % storeExecutorNameExpanded<__VA_ARGS__>() % QStringLiteral(">")
+#else
+    #define STORE_EXECUTOR_NAME(...)
+#endif
+
+#endif // ASYNC_DEBUG_H
\ No newline at end of file
diff --git a/async/src/future.cpp b/async/src/future.cpp
index 50a326a..4f3cd80 100644
--- a/async/src/future.cpp
+++ b/async/src/future.cpp
@@ -20,11 +20,41 @@
 
 using namespace Async;
 
+FutureBase::PrivateBase::PrivateBase(const Private::ExecutionPtr &execution)
+    : finished(false)
+    , errorCode(0)
+    , mExecution(execution)
+{
+}
+
+FutureBase::PrivateBase::~PrivateBase()
+{
+    Private::ExecutionPtr executionPtr = mExecution.toStrongRef();
+    if (executionPtr) {
+        executionPtr->releaseFuture();
+        releaseExecution();
+    }
+}
+
+void FutureBase::PrivateBase::releaseExecution()
+{
+    mExecution.clear();
+}
+
+
+
 FutureBase::FutureBase()
+    : d(nullptr)
+{
+}
+
+FutureBase::FutureBase(FutureBase::PrivateBase *dd)
+    : d(dd)
 {
 }
 
 FutureBase::FutureBase(const Async::FutureBase &other)
+    : d(other.d)
 {
 }
 
@@ -32,35 +62,97 @@ FutureBase::~FutureBase()
 {
 }
 
-FutureBase::PrivateBase::PrivateBase(const Private::ExecutionPtr &execution)
-    : mExecution(execution)
+void FutureBase::releaseExecution()
 {
+    d->releaseExecution();
 }
 
-FutureBase::PrivateBase::~PrivateBase()
+void FutureBase::setFinished()
 {
-    Private::ExecutionPtr executionPtr = mExecution.toStrongRef();
-    if (executionPtr) {
-        executionPtr->releaseFuture();
-        releaseExecution();
+    if (isFinished()) {
+        return;
+    }
+    d->finished = true;
+    for (auto watcher : d->watchers) {
+        if (watcher) {
+            watcher->futureReadyCallback();
+        }
     }
 }
 
-void FutureBase::PrivateBase::releaseExecution()
+bool FutureBase::isFinished() const
 {
-    mExecution.clear();
+    return d->finished;
+}
+
+void FutureBase::setError(int code, const QString &message)
+{
+    d->errorCode = code;
+    d->errorMessage = message;
+    setFinished();
+}
+
+int FutureBase::errorCode() const
+{
+    return d->errorCode;
+}
+
+QString FutureBase::errorMessage() const
+{
+    return d->errorMessage;
+}
+
+void FutureBase::setProgress(int processed, int total)
+{
+    setProgress((qreal) processed / total);
+}
+
+void FutureBase::setProgress(qreal progress)
+{
+    for (auto watcher : d->watchers) {
+        if (watcher) {
+            watcher->futureProgressCallback(progress);
+        }
+    }
 }
 
 
 
+void FutureBase::addWatcher(FutureWatcherBase* watcher)
+{
+    d->watchers.append(QPointer<FutureWatcherBase>(watcher));
+}
+
+
+
+
+
 FutureWatcherBase::FutureWatcherBase(QObject *parent)
     : QObject(parent)
+    , d(new FutureWatcherBase::Private)
 {
 }
 
 FutureWatcherBase::~FutureWatcherBase()
 {
+    delete d;
 }
 
+void FutureWatcherBase::futureReadyCallback()
+{
+    Q_EMIT futureReady();
+}
+
+void FutureWatcherBase::futureProgressCallback(qreal progress)
+{
+    Q_EMIT futureProgress(progress);
+}
 
-#include "future.moc"
+void FutureWatcherBase::setFutureImpl(const FutureBase &future)
+{
+    d->future = future;
+    d->future.addWatcher(this);
+    if (future.isFinished()) {
+        futureReadyCallback();
+    }
+}
diff --git a/async/src/future.h b/async/src/future.h
index cadd96d..ff199ef 100644
--- a/async/src/future.h
+++ b/async/src/future.h
@@ -29,28 +29,35 @@ class QEventLoop;
 
 namespace Async {
 
+class FutureWatcherBase;
+template<typename T>
+class FutureWatcher;
+
 namespace Private {
 class Execution;
 class ExecutorBase;
 
 typedef QSharedPointer<Execution> ExecutionPtr;
-
-}
+} // namespace Private
 
 class FutureBase
 {
     friend class Async::Private::Execution;
+    friend class FutureWatcherBase;
 
 public:
     virtual ~FutureBase();
 
-    virtual void setFinished() = 0;
-    virtual bool isFinished() const = 0;
-    virtual void setError(int code = 1, const QString &message = QString()) = 0;
+    void setFinished();
+    bool isFinished() const;
+    void setError(int code = 1, const QString &message = QString());
+    int errorCode() const;
+    QString errorMessage() const;
 
-protected:
-    virtual void releaseExecution() = 0;
+    void setProgress(qreal progress);
+    void setProgress(int processed, int total);
 
+protected:
     class PrivateBase : public QSharedData
     {
     public:
@@ -59,12 +66,24 @@ protected:
 
         void releaseExecution();
 
+        bool finished;
+        int errorCode;
+        QString errorMessage;
+
+        QVector<QPointer<FutureWatcherBase>> watchers;
     private:
         QWeakPointer<Async::Private::Execution> mExecution;
     };
 
     FutureBase();
+    FutureBase(FutureBase::PrivateBase *dd);
     FutureBase(const FutureBase &other);
+
+    void addWatcher(Async::FutureWatcherBase *watcher);
+    void releaseExecution();
+
+protected:
+    QExplicitlySharedDataPointer<PrivateBase> d;
 };
 
 template<typename T>
@@ -79,42 +98,7 @@ class FutureGeneric : public FutureBase
     friend class FutureWatcher<T>;
 
 public:
-    void setFinished()
-    {
-        if (d->finished) {
-            return;
-        }
-        d->finished = true;
-        for (auto watcher : d->watchers) {
-            if (watcher) {
-                watcher->futureReadyCallback();
-            }
-        }
-    }
-
-    bool isFinished() const
-    {
-        return d->finished;
-    }
-
-    void setError(int errorCode, const QString &message)
-    {
-        d->errorCode = errorCode;
-        d->errorMessage = message;
-        setFinished();
-    }
-
-    int errorCode() const
-    {
-        return d->errorCode;
-    }
-
-    QString errorMessage() const
-    {
-        return d->errorMessage;
-    }
-
-    void waitForFinished()
+    void waitForFinished() const
     {
         if (isFinished()) {
             return;
@@ -123,52 +107,33 @@ public:
         QEventLoop eventLoop;
         QObject::connect(&watcher, &Async::FutureWatcher<T>::futureReady,
                          &eventLoop, &QEventLoop::quit);
-        watcher.setFuture(*static_cast<Async::Future<T>*>(this));
+        watcher.setFuture(*static_cast<const Async::Future<T>*>(this));
         eventLoop.exec();
     }
 
 protected:
     FutureGeneric(const Async::Private::ExecutionPtr &execution)
-        : FutureBase()
-        , d(new Private(execution))
+        : FutureBase(new Private(execution))
     {}
 
     FutureGeneric(const FutureGeneric<T> &other)
         : FutureBase(other)
-        , d(other.d)
     {}
 
+protected:
     class Private : public FutureBase::PrivateBase
     {
     public:
         Private(const Async::Private::ExecutionPtr &execution)
             : FutureBase::PrivateBase(execution)
-            , finished(false)
-            , errorCode(0)
         {}
 
         typename std::conditional<std::is_void<T>::value, int /* dummy */, T>::type
         value;
-
-        QVector<QPointer<FutureWatcher<T>>> watchers;
-        bool finished;
-        int errorCode;
-        QString errorMessage;
     };
-
-    QExplicitlySharedDataPointer<Private> d;
-
-    void releaseExecution()
-    {
-        d->releaseExecution();
-    }
-
-    void addWatcher(FutureWatcher<T> *watcher)
-    {
-        d->watchers.append(QPointer<FutureWatcher<T>>(watcher));
-    }
 };
 
+
 template<typename T>
 class Future : public FutureGeneric<T>
 {
@@ -188,12 +153,12 @@ public:
 
     void setValue(const T &value)
     {
-        this->d->value = value;
+        static_cast<typename FutureGeneric<T>::Private*>(this->d.data())->value = value;
     }
 
     T value() const
     {
-        return this->d->value;
+        return static_cast<typename FutureGeneric<T>::Private*>(this->d.data())->value;
     }
 
 protected:
@@ -208,9 +173,6 @@ class Future<void> : public FutureGeneric<void>
 {
     friend class Async::Private::ExecutorBase;
 
-    template<typename T_>
-    friend class Async::FutureWatcher;
-
 public:
     Future()
         : FutureGeneric<void>(Async::Private::ExecutionPtr())
@@ -227,16 +189,38 @@ protected:
 };
 
 
+
+
+
 class FutureWatcherBase : public QObject
 {
     Q_OBJECT
 
+    friend class FutureBase;
+
+Q_SIGNALS:
+    void futureReady();
+    void futureProgress(qreal progress);
+
 protected:
     FutureWatcherBase(QObject *parent = nullptr);
     virtual ~FutureWatcherBase();
 
-Q_SIGNALS:
-    void futureReady();
+    void futureReadyCallback();
+    void futureProgressCallback(qreal progress);
+
+    void setFutureImpl(const Async::FutureBase &future);
+
+protected:
+    class Private {
+    public:
+        Async::FutureBase future;
+    };
+
+    Private * const d;
+
+private:
+    Q_DISABLE_COPY(FutureWatcherBase);
 };
 
 template<typename T>
@@ -254,25 +238,16 @@ public:
 
     void setFuture(const Async::Future<T> &future)
     {
-        mFuture = future;
-        mFuture.addWatcher(this);
-        if (future.isFinished()) {
-            futureReadyCallback();
-        }
+        setFutureImpl(*static_cast<const Async::FutureBase*>(&future));
     }
 
     Async::Future<T> future() const
     {
-        return mFuture;
+        return *static_cast<Async::Future<T>*>(&d->future);
     }
 
 private:
-    void futureReadyCallback()
-    {
-        Q_EMIT futureReady();
-    }
-
-    Async::Future<T> mFuture;
+    Q_DISABLE_COPY(FutureWatcher<T>);
 };
 
 } // namespace Async