KAsync has moved to it's own kasync.git repository

8 files changed, 0 insertions, 1738 deletions

diff --git a/async/src/CMakeLists.txt b/async/src/CMakeLists.txt
deleted file mode 100644
index 05d08b6..0000000
--- a/async/src/CMakeLists.txt
+++ /dev/null
@@ -1,63 +0,0 @@
-set(kasync_SRCS
-    async.cpp
-    future.cpp
-    debug.cpp
-)
-
-set(kasync_priv_HEADERS
-    async_impl.h
-    debug.h
-)
-
-ecm_generate_headers(kasync_HEADERS
-    HEADER_NAMES
-    Async
-    Future
-)
-
-
-add_library(KF5Async ${kasync_SRCS})
-add_library(KF5::Async ALIAS KF5Async)
-
-generate_export_header(KF5Async BASE_NAME kasync)
-
-target_include_directories(KF5Async INTERFACE "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR_KF5}/Async>")
-target_include_directories(KF5Async PUBLIC "$<BUILD_INTERFACE:${KAsync_SOURCE_DIR}/src>")
-
-target_link_libraries(KF5Async
-    PUBLIC
-        Qt5::Core
-)
-if (WITH_KJOB)
-    target_link_libraries(KF5Async PUBLIC KF5::CoreAddons)
-endif ()
-
-
-set_target_properties(KF5Async PROPERTIES
-    VERSION ${KASYNC_VERSION_STRING}
-    SOVERSION ${KASYNC_SOVERSION}
-    EXPORT_NAME KAsync
-)
-
-ecm_generate_pri_file(BASE_NAME KAsync
-    LIB_NAME KF5Async
-    FILENAME_VAR PRI_FILENAME
-)
-
-install(TARGETS
-    KF5Async
-    EXPORT KF5AsyncTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS}
-)
-
-install(FILES
-    ${CMAKE_CURRENT_BINARY_DIR}/kasync_export.h
-    ${kasync_HEADERS}
-    ${kasync_priv_HEADERS}
-    DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/Async
-    COMPONENT Devel
-)
-
-install(FILES
-    ${PRI_FILENAME}
-    DESTINATION ${ECM_MKSPECS_INSTALL_DIR}
-)
diff --git a/async/src/async.cpp b/async/src/async.cpp
deleted file mode 100644
index c57c9ad..0000000
--- a/async/src/async.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * Copyright 2014  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 "async.h"
-
-#include <QCoreApplication>
-#include <QDebug>
-#include <QEventLoop>
-#include <QTimer>
-
-using namespace KAsync;
-
-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)
-{
-}
-
-Private::ExecutorBase::~ExecutorBase()
-{
-}
-
-
-
-
-JobBase::JobBase(const Private::ExecutorBasePtr &executor)
-    : mExecutor(executor)
-{
-}
-
-JobBase::~JobBase()
-{
-}
-
-static void asyncWhile(const std::function<void(std::function<void(bool)>)> &body, const std::function<void()> &completionHandler) {
-    body([body, completionHandler](bool complete) {
-        if (complete) {
-            completionHandler();
-        } else {
-            asyncWhile(body, completionHandler);
-        }
-    });
-}
-
-Job<void> KAsync::dowhile(Condition condition, ThenTask<void> body)
-{
-    return KAsync::start<void>([body, condition](KAsync::Future<void> &future) {
-        asyncWhile([condition, body](std::function<void(bool)> whileCallback) {
-            KAsync::start<void>(body).then<void>([whileCallback, condition]() {
-                whileCallback(!condition());
-            }).exec();
-        },
-        [&future]() { //while complete
-            future.setFinished();
-        });
-    });
-}
-
-Job<void> KAsync::dowhile(ThenTask<bool> body)
-{
-    return KAsync::start<void>([body](KAsync::Future<void> &future) {
-        asyncWhile([body](std::function<void(bool)> whileCallback) {
-            KAsync::start<bool>(body).then<bool, bool>([whileCallback](bool result) {
-                whileCallback(!result);
-                //FIXME this return value is only required because .then<bool, void> doesn't work
-                return true;
-            }).exec();
-        },
-        [&future]() { //while complete
-            future.setFinished();
-        });
-    });
-}
-
-Job<void> KAsync::wait(int delay)
-{
-    auto timer = QSharedPointer<QTimer>::create();
-    return KAsync::start<void>([timer, delay](KAsync::Future<void> &future) {
-        timer->setSingleShot(true);
-        QObject::connect(timer.data(), &QTimer::timeout, [&future]() {
-            future.setFinished();
-        });
-        timer->start(delay);
-    });
-}
-
diff --git a/async/src/async.h b/async/src/async.h
deleted file mode 100644
index 152f98e..0000000
--- a/async/src/async.h
+++ /dev/null
@@ -1,874 +0,0 @@
-/*
- * Copyright 2014 - 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 KASYNC_H
-#define KASYNC_H
-
-#include "kasync_export.h"
-
-#include <functional>
-#include <list>
-#include <type_traits>
-#include <cassert>
-#include <iterator>
-
-#include "future.h"
-#include "debug.h"
-#include "async_impl.h"
-
-#include <QVector>
-#include <QObject>
-#include <QSharedPointer>
-
-#include <QDebug>
-
-#ifdef WITH_KJOB
-#include <KJob>
-#endif
-
-
-/*
- * API to help write async code.
- *
- * This API is based around jobs that take lambdas to execute asynchronous tasks. Each async operation can take a continuation,
- * that can then be used to execute further async operations. That way it is possible to build async chains of operations,
- * that can be stored and executed later on. Jobs can be composed, similarly to functions.
- *
- * Relations between the components:
- * * 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
- *
- *
- * 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.
- */
-namespace KAsync {
-
-template<typename PrevOut, typename Out, typename ... In>
-class Executor;
-
-class JobBase;
-
-template<typename Out, typename ... In>
-class Job;
-
-template<typename Out, typename ... In>
-using ThenTask = typename detail::identity<std::function<void(In ..., KAsync::Future<Out>&)>>::type;
-template<typename Out, typename ... In>
-using SyncThenTask = typename detail::identity<std::function<Out(In ...)>>::type;
-template<typename Out, typename In>
-using EachTask = typename detail::identity<std::function<void(In, KAsync::Future<Out>&)>>::type;
-template<typename Out, typename In>
-using SyncEachTask = typename detail::identity<std::function<Out(In)>>::type;
-template<typename Out, typename In>
-using ReduceTask = typename detail::identity<std::function<void(In, KAsync::Future<Out>&)>>::type;
-template<typename Out, typename In>
-using SyncReduceTask = typename detail::identity<std::function<Out(In)>>::type;
-
-using ErrorHandler = std::function<void(int, const QString &)>;
-using Condition = std::function<bool()>;
-
-namespace Private
-{
-
-class ExecutorBase;
-typedef QSharedPointer<ExecutorBase> ExecutorBasePtr;
-
-struct KASYNC_EXPORT Execution {
-    Execution(const ExecutorBasePtr &executor);
-    ~Execution();
-    void setFinished();
-
-    template<typename T>
-    KAsync::Future<T>* result() const
-    {
-        return static_cast<KAsync::Future<T>*>(resultBase);
-    }
-
-    void releaseFuture();
-    bool errorWasHandled() const;
-
-    ExecutorBasePtr executor;
-    FutureBase *resultBase;
-    bool isRunning;
-    bool isFinished;
-
-    ExecutionPtr prevExecution;
-
-#ifndef QT_NO_DEBUG
-    Tracer *tracer;
-#endif
-};
-
-
-typedef QSharedPointer<Execution> ExecutionPtr;
-
-class KASYNC_EXPORT ExecutorBase
-{
-    template<typename PrevOut, typename Out, typename ... In>
-    friend class Executor;
-
-    template<typename Out, typename ... In>
-    friend class KAsync::Job;
-
-    friend class Execution;
-    friend class KAsync::Tracer;
-
-public:
-    virtual ~ExecutorBase();
-    virtual ExecutionPtr exec(const ExecutorBasePtr &self) = 0;
-
-protected:
-    ExecutorBase(const ExecutorBasePtr &parent);
-
-    template<typename T>
-    KAsync::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 errorFunc, const Private::ExecutorBasePtr &parent)
-        : ExecutorBase(parent)
-        , 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;
-};
-
-template<typename Out, typename ... In>
-class ThenExecutor: public Executor<typename detail::prevOut<In ...>::type, Out, In ...>
-{
-public:
-    ThenExecutor(ThenTask<Out, In ...> then, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
-    void run(const ExecutionPtr &execution);
-private:
-    ThenTask<Out, In ...> mFunc;
-};
-
-template<typename PrevOut, typename Out, typename In>
-class EachExecutor : public Executor<PrevOut, Out, In>
-{
-public:
-    EachExecutor(EachTask<Out, In> each, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
-    void run(const ExecutionPtr &execution);
-private:
-    EachTask<Out, In> mFunc;
-    QVector<KAsync::FutureWatcher<Out>*> mFutureWatchers;
-};
-
-template<typename Out, typename In>
-class ReduceExecutor : public ThenExecutor<Out, In>
-{
-public:
-    ReduceExecutor(ReduceTask<Out, In> reduce, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
-private:
-    ReduceTask<Out, In> mFunc;
-};
-
-template<typename Out, typename ... In>
-class SyncThenExecutor : public Executor<typename detail::prevOut<In ...>::type, Out, In ...>
-{
-public:
-    SyncThenExecutor(SyncThenTask<Out, In ...> then, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
-    void run(const ExecutionPtr &execution);
-
-private:
-    void run(const ExecutionPtr &execution, std::false_type); // !std::is_void<Out>
-    void run(const ExecutionPtr &execution, std::true_type);  // std::is_void<Out>
-    SyncThenTask<Out, In ...> mFunc;
-};
-
-template<typename Out, typename In>
-class SyncReduceExecutor : public SyncThenExecutor<Out, In>
-{
-public:
-    SyncReduceExecutor(SyncReduceTask<Out, In> reduce, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
-private:
-    SyncReduceTask<Out, In> mFunc;
-};
-
-template<typename PrevOut, typename Out, typename In>
-class SyncEachExecutor : public Executor<PrevOut, Out, In>
-{
-public:
-    SyncEachExecutor(SyncEachTask<Out, In> each, ErrorHandler errorFunc, const ExecutorBasePtr &parent);
-    void run(const ExecutionPtr &execution);
-private:
-    void run(KAsync::Future<Out> *future, const typename PrevOut::value_type &arg, std::false_type); // !std::is_void<Out>
-    void run(KAsync::Future<Out> *future, const typename PrevOut::value_type &arg, std::true_type);  // std::is_void<Out>
-    SyncEachTask<Out, In> mFunc;
-};
-
-} // namespace Private
-
-/**
- * Start an asynchronous job sequence.
- *
- * KAsync::start() is your starting point to build a chain of jobs to be executed
- * asynchronously.
- *
- * @param func An asynchronous function to be executed. The function must have
- *             void return type, and accept exactly one argument of type @p KAsync::Future<In>,
- *             where @p In is type of the result.
- */
-template<typename Out, typename ... In>
-Job<Out, In ...> start(ThenTask<Out, In ...> func, ErrorHandler errorFunc = ErrorHandler());
-
-template<typename Out, typename ... In>
-Job<Out, In ...> start(SyncThenTask<Out, In ...> func, ErrorHandler errorFunc = ErrorHandler());
-
-#ifdef WITH_KJOB
-template<typename ReturnType, typename KJobType, ReturnType (KJobType::*KJobResultMethod)(), typename ... Args>
-Job<ReturnType, Args ...> start();
-#endif
-
-/**
- * Async while loop.
- * 
- * The loop continues while @param condition returns true.
- */
-KASYNC_EXPORT Job<void> dowhile(Condition condition, ThenTask<void> func);
-
-/**
- * Async while loop.
- *
- * Loop continues while body returns true.
- */
-KASYNC_EXPORT Job<void> dowhile(ThenTask<bool> body);
-
-/**
- * Iterate over a container.
- *
- * Use in conjunction with .each
- */
-template<typename Out>
-Job<Out> iterate(const Out &container);
-
-/**
- * Async delay.
- */
-KASYNC_EXPORT Job<void> wait(int delay);
-
-/**
- * A null job.
- *
- * An async noop.
- *
- */
-template<typename Out>
-Job<Out> null();
-
-/**
- * An error job.
- *
- * An async error.
- *
- */
-template<typename Out>
-Job<Out> error(int errorCode = 1, const QString &errorMessage = QString());
-
-class KASYNC_EXPORT JobBase
-{
-    template<typename Out, typename ... In>
-    friend class Job;
-
-public:
-    JobBase(const Private::ExecutorBasePtr &executor);
-    ~JobBase();
-
-protected:
-    Private::ExecutorBasePtr mExecutor;
-};
-
-/**
- * An Asynchronous job
- *
- * A single instance of Job represents a single method that will be executed
- * asynchrously. The Job is started by @p Job::exec(), which returns @p KAsync::Future
- * immediatelly. The Future will be set to finished state once the asynchronous
- * task has finished. You can use @p KAsync::Future::waitForFinished() to wait for
- * for the Future in blocking manner.
- *
- * It is possible to chain multiple Jobs one after another in different fashion
- * (sequential, parallel, etc.). Calling Job::exec() will then return a pending
- * @p KAsync::Future, and will execute the entire chain of jobs.
- *
- * @code
- * auto job = Job::start<QList<int>>(
- *     [](KAsync::Future<QList<int>> &future) {
- *         MyREST::PendingUsers *pu = MyREST::requestListOfUsers();
- *         QObject::connect(pu, &PendingOperation::finished,
- *                          [&](PendingOperation *pu) {
- *                              future->setValue(dynamic_cast<MyREST::PendingUsers*>(pu)->userIds());
- *                              future->setFinished();
- *                          });
- *      })
- * .each<QList<MyREST::User>, int>(
- *      [](const int &userId, KAsync::Future<QList<MyREST::User>> &future) {
- *          MyREST::PendingUser *pu = MyREST::requestUserDetails(userId);
- *          QObject::connect(pu, &PendingOperation::finished,
- *                           [&](PendingOperation *pu) {
- *                              future->setValue(Qlist<MyREST::User>() << dynamic_cast<MyREST::PendingUser*>(pu)->user());
- *                              future->setFinished();
- *                           });
- *      });
- *
- * KAsync::Future<QList<MyREST::User>> usersFuture = job.exec();
- * usersFuture.waitForFinished();
- * QList<MyRest::User> users = usersFuture.value();
- * @endcode
- *
- * In the example above, calling @p job.exec() will first invoke the first job,
- * which will retrieve a list of IDs, and then will invoke the second function
- * for each single entry in the list returned by the first function.
- */
-template<typename Out, typename ... In>
-class Job : public JobBase
-{
-    template<typename OutOther, typename ... InOther>
-    friend class Job;
-
-    template<typename OutOther, typename ... InOther>
-    friend Job<OutOther, InOther ...> start(KAsync::ThenTask<OutOther, InOther ...> func, ErrorHandler errorFunc);
-
-    template<typename OutOther, typename ... InOther>
-    friend Job<OutOther, InOther ...> start(KAsync::SyncThenTask<OutOther, InOther ...> func, ErrorHandler errorFunc);
-
-#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())
-    {
-        return Job<OutOther, InOther ...>(Private::ExecutorBasePtr(
-            new Private::ThenExecutor<OutOther, InOther ...>(func, errorFunc, mExecutor)));
-    }
-
-    template<typename OutOther, typename ... InOther>
-    Job<OutOther, InOther ...> then(SyncThenTask<OutOther, InOther ...> func, ErrorHandler errorFunc = ErrorHandler())
-    {
-        return Job<OutOther, InOther ...>(Private::ExecutorBasePtr(
-            new Private::SyncThenExecutor<OutOther, InOther ...>(func, errorFunc, mExecutor)));
-    }
-
-    template<typename OutOther, typename ... InOther>
-    Job<OutOther, InOther ...> then(Job<OutOther, InOther ...> otherJob, ErrorHandler errorFunc = ErrorHandler())
-    {
-        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())
-    {
-        eachInvariants<OutOther>();
-        return Job<OutOther, InOther>(Private::ExecutorBasePtr(
-            new Private::EachExecutor<Out, OutOther, InOther>(func, errorFunc, mExecutor)));
-    }
-
-    template<typename OutOther, typename InOther>
-    Job<OutOther, InOther> each(SyncEachTask<OutOther, InOther> func, ErrorHandler errorFunc = ErrorHandler())
-    {
-        eachInvariants<OutOther>();
-        return Job<OutOther, InOther>(Private::ExecutorBasePtr(
-            new Private::SyncEachExecutor<Out, OutOther, InOther>(func, errorFunc, mExecutor)));
-    }
-
-    template<typename OutOther, typename InOther>
-    Job<OutOther, InOther> each(Job<OutOther, InOther> otherJob, ErrorHandler errorFunc = ErrorHandler())
-    {
-        eachInvariants<OutOther>();
-        return each<OutOther, InOther>(nestedJobWrapper<OutOther, InOther>(otherJob), errorFunc);
-    }
-
-    template<typename OutOther, typename InOther>
-    Job<OutOther, InOther> reduce(ReduceTask<OutOther, InOther> func, ErrorHandler errorFunc = ErrorHandler())
-    {
-        reduceInvariants<InOther>();
-        return Job<OutOther, InOther>(Private::ExecutorBasePtr(
-            new Private::ReduceExecutor<OutOther, InOther>(func, errorFunc, mExecutor)));
-    }
-
-    template<typename OutOther, typename InOther>
-    Job<OutOther, InOther> reduce(SyncReduceTask<OutOther, InOther> func, ErrorHandler errorFunc = ErrorHandler())
-    {
-        reduceInvariants<InOther>();
-        return Job<OutOther, InOther>(Private::ExecutorBasePtr(
-            new Private::SyncReduceExecutor<OutOther, InOther>(func, errorFunc, mExecutor)));
-    }
-
-    template<typename OutOther, typename InOther>
-    Job<OutOther, InOther> reduce(Job<OutOther, InOther> otherJob, ErrorHandler errorFunc = ErrorHandler())
-    {
-        return reduce<OutOther, InOther>(nestedJobWrapper<OutOther, InOther>(otherJob), errorFunc);
-    }
-
-    template<typename FirstIn>
-    KAsync::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;
-    }
-
-    KAsync::Future<Out> exec()
-    {
-        Private::ExecutionPtr execution = mExecutor->exec(mExecutor);
-        KAsync::Future<Out> result = *execution->result<Out>();
-
-        return result;
-    }
-
-private:
-    Job(Private::ExecutorBasePtr executor)
-        : JobBase(executor)
-    {}
-
-    template<typename OutOther>
-    void eachInvariants()
-    {
-        static_assert(detail::isIterable<Out>::value,
-                      "The 'Each' task can only be connected to a job that returns a list or an array.");
-        static_assert(std::is_void<OutOther>::value || detail::isIterable<OutOther>::value,
-                      "The result type of 'Each' task must be void, a list or an array.");
-    }
-
-    template<typename InOther>
-    void reduceInvariants()
-    {
-        static_assert(KAsync::detail::isIterable<Out>::value,
-                      "The 'Result' task can only be connected to a job that returns a list or an array");
-        static_assert(std::is_same<typename Out::value_type, typename InOther::value_type>::value,
-                      "The return type of previous task must be compatible with input type of this task");
-    }
-
-    template<typename OutOther, typename ... InOther>
-    inline std::function<void(InOther ..., KAsync::Future<OutOther>&)> nestedJobWrapper(Job<OutOther, InOther ...> otherJob) {
-        return [otherJob](InOther ... in, KAsync::Future<OutOther> &future) {
-            // copy by value is const
-            auto job = otherJob;
-            FutureWatcher<OutOther> *watcher = new FutureWatcher<OutOther>();
-            QObject::connect(watcher, &FutureWatcherBase::futureReady,
-                             [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;
-                                 KAsync::detail::copyFutureValue(watcher->future(), outFuture);
-                                 if (watcher->future().errorCode()) {
-                                     outFuture.setError(watcher->future().errorCode(), watcher->future().errorMessage());
-                                 } else {
-                                     outFuture.setFinished();
-                                 }
-                                 delete watcher;
-                             });
-            watcher->setFuture(job.exec(in ...));
-        };
-    }
-};
-
-} // namespace KAsync
-
-
-// ********** Out of line definitions ****************
-
-namespace KAsync {
-
-template<typename Out, typename ... In>
-Job<Out, In ...> start(ThenTask<Out, In ...> func, ErrorHandler error)
-{
-    return Job<Out, In...>(Private::ExecutorBasePtr(
-        new Private::ThenExecutor<Out, In ...>(func, error, Private::ExecutorBasePtr())));
-}
-
-template<typename Out, typename ... In>
-Job<Out, In ...> start(SyncThenTask<Out, In ...> func, ErrorHandler error)
-{
-    return Job<Out, In...>(Private::ExecutorBasePtr(
-        new Private::SyncThenExecutor<Out, In ...>(func, error, 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, KAsync::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()
-{
-    return KAsync::start<Out>(
-        [](KAsync::Future<Out> &future) {
-            future.setFinished();
-        });
-}
-
-template<typename Out>
-Job<Out> error(int errorCode, const QString &errorMessage)
-{
-    return KAsync::start<Out>(
-        [errorCode, errorMessage](KAsync::Future<Out> &future) {
-            future.setError(errorCode, errorMessage);
-        });
-}
-
-template<typename Out>
-Job<Out> iterate(const Out &container)
-{
-    return KAsync::start<Out>(
-        [container]() {
-            return container;
-        });
-}
-
-
-namespace Private {
-
-template<typename T>
-KAsync::Future<T>* ExecutorBase::createFuture(const ExecutionPtr &execution) const
-{
-    return new KAsync::Future<T>(execution);
-}
-
-template<typename PrevOut, typename Out, typename ... In>
-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();
-
-    execution->resultBase = ExecutorBase::createFuture<Out>(execution);
-    auto fw = new KAsync::FutureWatcher<Out>();
-    QObject::connect(fw, &KAsync::FutureWatcher<Out>::futureReady,
-                     [fw, execution, this]() {
-                         handleError(execution);
-                         execution->setFinished();
-                         delete fw;
-                     });
-    fw->setFuture(*execution->result<Out>());
-
-    KAsync::Future<PrevOut> *prevFuture = execution->prevExecution ? execution->prevExecution->result<PrevOut>() : nullptr;
-    if (!prevFuture || prevFuture->isFinished()) {
-        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 error (if any)
-            }
-        }
-
-        execution->isRunning = true;
-        run(execution);
-    } else {
-        auto prevFutureWatcher = new KAsync::FutureWatcher<PrevOut>();
-        QObject::connect(prevFutureWatcher, &KAsync::FutureWatcher<PrevOut>::futureReady,
-                         [prevFutureWatcher, execution, this]() {
-                             auto prevFuture = prevFutureWatcher->future();
-                             assert(prevFuture.isFinished());
-                             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 {
-                                     return;
-                                 }
-                             }
-
-
-                             // propagate error (if any)
-                             execution->isRunning = true;
-                             run(execution);
-                         });
-
-        prevFutureWatcher->setFuture(*static_cast<KAsync::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>
-void ThenExecutor<Out, In ...>::run(const ExecutionPtr &execution)
-{
-    KAsync::Future<typename detail::prevOut<In ...>::type> *prevFuture = nullptr;
-    if (execution->prevExecution) {
-        prevFuture = execution->prevExecution->result<typename detail::prevOut<In ...>::type>();
-        assert(prevFuture->isFinished());
-    }
-
-    ThenExecutor<Out, In ...>::mFunc(prevFuture ? prevFuture->value() : In() ..., *execution->result<Out>());
-}
-
-template<typename PrevOut, typename Out, typename In>
-EachExecutor<PrevOut, Out, In>::EachExecutor(EachTask<Out, In> each, ErrorHandler error, const ExecutorBasePtr &parent)
-    : Executor<PrevOut, Out, In>(error, parent)
-    , mFunc(each)
-{
-    STORE_EXECUTOR_NAME("EachExecutor", PrevOut, Out, In);
-}
-
-template<typename PrevOut, typename Out, typename In>
-void EachExecutor<PrevOut, Out, In>::run(const ExecutionPtr &execution)
-{
-    assert(execution->prevExecution);
-    auto prevFuture = execution->prevExecution->result<PrevOut>();
-    assert(prevFuture->isFinished());
-
-    auto out = execution->result<Out>();
-    if (prevFuture->value().isEmpty()) {
-        out->setFinished();
-        return;
-    }
-
-    for (auto arg : prevFuture->value()) {
-        //We have to manually manage the lifetime of these temporary futures
-        KAsync::Future<Out> *future = new KAsync::Future<Out>();
-        EachExecutor<PrevOut, Out, In>::mFunc(arg, *future);
-        auto fw = new KAsync::FutureWatcher<Out>();
-        mFutureWatchers.append(fw);
-        QObject::connect(fw, &KAsync::FutureWatcher<Out>::futureReady,
-                         [out, fw, this, future]() {
-                             assert(fw->future().isFinished());
-                             const int index = mFutureWatchers.indexOf(fw);
-                             assert(index > -1);
-                             mFutureWatchers.removeAt(index);
-                             KAsync::detail::aggregateFutureValue<Out>(fw->future(), *out);
-                             if (mFutureWatchers.isEmpty()) {
-                                 out->setFinished();
-                             }
-                             delete fw;
-                             delete future;
-                         });
-        fw->setFuture(*future);
-    }
-}
-
-template<typename Out, typename In>
-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 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>
-void SyncThenExecutor<Out, In ...>::run(const ExecutionPtr &execution)
-{
-    if (execution->prevExecution) {
-        assert(execution->prevExecution->resultBase->isFinished());
-    }
-
-    run(execution, std::is_void<Out>());
-    execution->resultBase->setFinished();
-}
-
-template<typename Out, typename ... In>
-void SyncThenExecutor<Out, In ...>::run(const ExecutionPtr &execution, std::false_type)
-{
-    KAsync::Future<typename detail::prevOut<In ...>::type> *prevFuture =
-        execution->prevExecution
-            ? execution->prevExecution->result<typename detail::prevOut<In ...>::type>()
-            : nullptr;
-    (void) prevFuture; // silence 'set but not used' warning
-    KAsync::Future<Out> *future = execution->result<Out>();
-    future->setValue(SyncThenExecutor<Out, In...>::mFunc(prevFuture ? prevFuture->value() : In() ...));
-}
-
-template<typename Out, typename ... In>
-void SyncThenExecutor<Out, In ...>::run(const ExecutionPtr &execution, std::true_type)
-{
-    KAsync::Future<typename detail::prevOut<In ...>::type> *prevFuture =
-        execution->prevExecution
-            ? execution->prevExecution->result<typename detail::prevOut<In ...>::type>()
-            : nullptr;
-    (void) prevFuture; // silence 'set but not used' warning
-    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 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>
-void SyncEachExecutor<PrevOut, Out, In>::run(const ExecutionPtr &execution)
-{
-    assert(execution->prevExecution);
-    auto *prevFuture = execution->prevExecution->result<PrevOut>();
-    assert(prevFuture->isFinished());
-
-    auto out = execution->result<Out>();
-    if (prevFuture->value().isEmpty()) {
-        out->setFinished();
-        return;
-    }
-
-    for (auto arg : prevFuture->value()) {
-        run(out, arg, std::is_void<Out>());
-    }
-    out->setFinished();
-}
-
-template<typename PrevOut, typename Out, typename In>
-void SyncEachExecutor<PrevOut, Out, In>::run(KAsync::Future<Out> *out, const typename PrevOut::value_type &arg, std::false_type)
-{
-    out->setValue(out->value() + SyncEachExecutor<PrevOut, Out, In>::mFunc(arg));
-}
-
-template<typename PrevOut, typename Out, typename In>
-void SyncEachExecutor<PrevOut, Out, In>::run(KAsync::Future<Out> * /* unused */, const typename PrevOut::value_type &arg, std::true_type)
-{
-    SyncEachExecutor<PrevOut, Out, In>::mFunc(arg);
-}
-
-template<typename Out, typename In>
-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);
-}
-
-
-} // namespace Private
-
-} // namespace KAsync
-
-
-
-#endif // KASYNC_H
-
-
diff --git a/async/src/async_impl.h b/async/src/async_impl.h
deleted file mode 100644
index 5b4e393..0000000
--- a/async/src/async_impl.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * Copyright 2014 - 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 KASYNC_IMPL_H
-#define KASYNC_IMPL_H
-
-#include "async.h"
-#include <type_traits>
-
-namespace KAsync {
-
-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 };
-};
-
-template<typename ... T>
-struct prevOut {
-    using type = typename std::tuple_element<0, std::tuple<T ..., void>>::type;
-};
-
-template<typename T>
-inline typename std::enable_if<!std::is_void<T>::value, void>::type
-copyFutureValue(const KAsync::Future<T> &in, KAsync::Future<T> &out)
-{
-    out.setValue(in.value());
-}
-
-template<typename T>
-inline typename std::enable_if<std::is_void<T>::value, void>::type
-copyFutureValue(const KAsync::Future<T> &in, KAsync::Future<T> &out)
-{
-    // noop
-}
-
-template<typename T>
-inline typename std::enable_if<!std::is_void<T>::value, void>::type
-aggregateFutureValue(const KAsync::Future<T> &in, KAsync::Future<T> &out)
-{
-    out.setValue(out.value() + in.value());
-}
-
-template<typename T>
-inline typename std::enable_if<std::is_void<T>::value, void>::type
-aggregateFutureValue(const KAsync::Future<T> &in, KAsync::Future<T> &out)
-{
-    // noop
-}
-
-} // namespace Detail
-
-} // namespace KAsync
-
-#endif // KASYNC_IMPL_H
diff --git a/async/src/debug.cpp b/async/src/debug.cpp
deleted file mode 100644
index 64a3a3b..0000000
--- a/async/src/debug.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * 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 KAsync
-{
-
-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::fromLatin1(demangled.get());
-    }
-#endif
-    return QString::fromLatin1(name);
-}
-
-}
-
-using namespace KAsync;
-
-int Tracer::lastId = 0;
-
-Tracer::Tracer(Private::Execution *execution)
-    : mId(lastId++)
-    , mExecution(execution)
-{
-    msg(KAsync::Tracer::Start);
-}
-
-Tracer::~Tracer()
-{
-    msg(KAsync::Tracer::End);
-    // FIXME: Does this work on parallel executions?
-    --lastId;
-    --mId;
-}
-
-void Tracer::msg(Tracer::MsgType msgType)
-{
-#ifndef QT_NO_DEBUG
-    qCDebug(Trace).nospace() << (QString().fill(QLatin1Char(' '), mId * 2) % 
-                                 (msgType == KAsync::Tracer::Start ? QStringLiteral(" START ") : QStringLiteral(" END   ")) %
-                                 QString::number(mId) % QStringLiteral(" ") %
-                                 mExecution->executor->mExecutorName);
-#endif
-}
diff --git a/async/src/debug.h b/async/src/debug.h
deleted file mode 100644
index b2b2ff7..0000000
--- a/async/src/debug.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * 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 KASYNC_DEBUG_H
-#define KASYNC_DEBUG_H
-
-#include "kasync_export.h"
-
-#include <QLoggingCategory>
-#include <QStringBuilder>
-
-#ifndef QT_NO_DEBUG
-#include <typeinfo>
-#endif
-
-namespace KAsync
-{
-
-Q_DECLARE_LOGGING_CATEGORY(Debug)
-Q_DECLARE_LOGGING_CATEGORY(Trace)
-
-KASYNC_EXPORT QString demangleName(const char *name);
-
-namespace Private
-{
-class Execution;
-}
-
-class KASYNC_EXPORT 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 KAsync::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 // KASYNC_DEBUG_H
\ No newline at end of file
diff --git a/async/src/future.cpp b/async/src/future.cpp
deleted file mode 100644
index 9281cc8..0000000
--- a/async/src/future.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright 2014  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 "future.h"
-#include "async.h"
-
-using namespace KAsync;
-
-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 KAsync::FutureBase &other)
-    : d(other.d)
-{
-}
-
-FutureBase::~FutureBase()
-{
-}
-
-void FutureBase::releaseExecution()
-{
-    d->releaseExecution();
-}
-
-void FutureBase::setFinished()
-{
-    if (isFinished()) {
-        return;
-    }
-    d->finished = true;
-    for (auto watcher : d->watchers) {
-        if (watcher) {
-            watcher->futureReadyCallback();
-        }
-    }
-}
-
-bool FutureBase::isFinished() const
-{
-    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);
-}
-
-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
deleted file mode 100644
index b2b723e..0000000
--- a/async/src/future.h
+++ /dev/null
@@ -1,257 +0,0 @@
-/*
- * Copyright 2014  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 FUTURE_H
-#define FUTURE_H
-
-#include "kasync_export.h"
-
-class QEventLoop;
-
-#include <type_traits>
-
-#include <QSharedDataPointer>
-#include <QPointer>
-#include <QVector>
-#include <QEventLoop>
-
-namespace KAsync {
-
-class FutureWatcherBase;
-template<typename T>
-class FutureWatcher;
-
-namespace Private {
-class Execution;
-class ExecutorBase;
-
-typedef QSharedPointer<Execution> ExecutionPtr;
-} // namespace Private
-
-class KASYNC_EXPORT FutureBase
-{
-    friend class KAsync::Private::Execution;
-    friend class FutureWatcherBase;
-
-public:
-    virtual ~FutureBase();
-
-    void setFinished();
-    bool isFinished() const;
-    void setError(int code = 1, const QString &message = QString());
-    int errorCode() const;
-    QString errorMessage() const;
-
-    void setProgress(qreal progress);
-    void setProgress(int processed, int total);
-
-protected:
-    class PrivateBase : public QSharedData
-    {
-    public:
-        PrivateBase(const KAsync::Private::ExecutionPtr &execution);
-        virtual ~PrivateBase();
-
-        void releaseExecution();
-
-        bool finished;
-        int errorCode;
-        QString errorMessage;
-
-        QVector<QPointer<FutureWatcherBase>> watchers;
-    private:
-        QWeakPointer<KAsync::Private::Execution> mExecution;
-    };
-
-    FutureBase();
-    FutureBase(FutureBase::PrivateBase *dd);
-    FutureBase(const FutureBase &other);
-
-    void addWatcher(KAsync::FutureWatcherBase *watcher);
-    void releaseExecution();
-
-protected:
-    QExplicitlySharedDataPointer<PrivateBase> d;
-};
-
-template<typename T>
-class FutureWatcher;
-
-template<typename T>
-class Future;
-
-template<typename T>
-class FutureGeneric : public FutureBase
-{
-    friend class FutureWatcher<T>;
-
-public:
-    void waitForFinished() const
-    {
-        if (isFinished()) {
-            return;
-        }
-        FutureWatcher<T> watcher;
-        QEventLoop eventLoop;
-        QObject::connect(&watcher, &KAsync::FutureWatcher<T>::futureReady,
-                         &eventLoop, &QEventLoop::quit);
-        watcher.setFuture(*static_cast<const KAsync::Future<T>*>(this));
-        eventLoop.exec();
-    }
-
-protected:
-    FutureGeneric(const KAsync::Private::ExecutionPtr &execution)
-        : FutureBase(new Private(execution))
-    {}
-
-    FutureGeneric(const FutureGeneric<T> &other)
-        : FutureBase(other)
-    {}
-
-protected:
-    class Private : public FutureBase::PrivateBase
-    {
-    public:
-        Private(const KAsync::Private::ExecutionPtr &execution)
-            : FutureBase::PrivateBase(execution)
-        {}
-
-        typename std::conditional<std::is_void<T>::value, int /* dummy */, T>::type
-        value;
-    };
-};
-
-
-template<typename T>
-class Future : public FutureGeneric<T>
-{
-    friend class KAsync::Private::ExecutorBase;
-
-    template<typename T_>
-    friend class KAsync::FutureWatcher;
-
-public:
-    Future()
-        : FutureGeneric<T>(KAsync::Private::ExecutionPtr())
-    {}
-
-    Future(const Future<T> &other)
-        : FutureGeneric<T>(other)
-    {}
-
-    void setValue(const T &value)
-    {
-        static_cast<typename FutureGeneric<T>::Private*>(this->d.data())->value = value;
-    }
-
-    T value() const
-    {
-        return static_cast<typename FutureGeneric<T>::Private*>(this->d.data())->value;
-    }
-
-protected:
-    Future(const KAsync::Private::ExecutionPtr &execution)
-        : FutureGeneric<T>(execution)
-    {}
-
-};
-
-template<>
-class Future<void> : public FutureGeneric<void>
-{
-    friend class KAsync::Private::ExecutorBase;
-
-public:
-    Future()
-        : FutureGeneric<void>(KAsync::Private::ExecutionPtr())
-    {}
-
-    Future(const Future<void> &other)
-        : FutureGeneric<void>(other)
-    {}
-
-protected:
-    Future(const KAsync::Private::ExecutionPtr &execution)
-        : FutureGeneric<void>(execution)
-    {}
-};
-
-
-
-
-
-class KASYNC_EXPORT FutureWatcherBase : public QObject
-{
-    Q_OBJECT
-
-    friend class FutureBase;
-
-Q_SIGNALS:
-    void futureReady();
-    void futureProgress(qreal progress);
-
-protected:
-    FutureWatcherBase(QObject *parent = nullptr);
-    virtual ~FutureWatcherBase();
-
-    void futureReadyCallback();
-    void futureProgressCallback(qreal progress);
-
-    void setFutureImpl(const KAsync::FutureBase &future);
-
-protected:
-    class Private {
-    public:
-        KAsync::FutureBase future;
-    };
-
-    Private * const d;
-
-private:
-    Q_DISABLE_COPY(FutureWatcherBase);
-};
-
-template<typename T>
-class FutureWatcher : public FutureWatcherBase
-{
-    friend class KAsync::FutureGeneric<T>;
-
-public:
-    FutureWatcher(QObject *parent = nullptr)
-        : FutureWatcherBase(parent)
-    {}
-
-    ~FutureWatcher()
-    {}
-
-    void setFuture(const KAsync::Future<T> &future)
-    {
-        setFutureImpl(*static_cast<const KAsync::FutureBase*>(&future));
-    }
-
-    KAsync::Future<T> future() const
-    {
-        return *static_cast<KAsync::Future<T>*>(&d->future);
-    }
-
-private:
-    Q_DISABLE_COPY(FutureWatcher<T>);
-};
-
-} // namespace Async
-
-#endif // FUTURE_H