Async: rename Async namespace to KAsync

7 files changed, 133 insertions, 127 deletions

diff --git a/async/src/async.cpp b/async/src/async.cpp
index 0e86a84..c57c9ad 100644
--- a/async/src/async.cpp
+++ b/async/src/async.cpp
@@ -22,7 +22,7 @@
 #include <QEventLoop>
 #include <QTimer>
 
-using namespace Async;
+using namespace KAsync;
 
 Private::Execution::Execution(const Private::ExecutorBasePtr &executor)
     : executor(executor)
@@ -104,11 +104,11 @@ static void asyncWhile(const std::function<void(std::function<void(bool)>)> &bod
     });
 }
 
-Job<void> Async::dowhile(Condition condition, ThenTask<void> body)
+Job<void> KAsync::dowhile(Condition condition, ThenTask<void> body)
 {
-    return Async::start<void>([body, condition](Async::Future<void> &future) {
+    return KAsync::start<void>([body, condition](KAsync::Future<void> &future) {
         asyncWhile([condition, body](std::function<void(bool)> whileCallback) {
-            Async::start<void>(body).then<void>([whileCallback, condition]() {
+            KAsync::start<void>(body).then<void>([whileCallback, condition]() {
                 whileCallback(!condition());
             }).exec();
         },
@@ -118,11 +118,11 @@ Job<void> Async::dowhile(Condition condition, ThenTask<void> body)
     });
 }
 
-Job<void> Async::dowhile(ThenTask<bool> body)
+Job<void> KAsync::dowhile(ThenTask<bool> body)
 {
-    return Async::start<void>([body](Async::Future<void> &future) {
+    return KAsync::start<void>([body](KAsync::Future<void> &future) {
         asyncWhile([body](std::function<void(bool)> whileCallback) {
-            Async::start<bool>(body).then<bool, bool>([whileCallback](bool result) {
+            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;
@@ -134,10 +134,10 @@ Job<void> Async::dowhile(ThenTask<bool> body)
     });
 }
 
-Job<void> Async::wait(int delay)
+Job<void> KAsync::wait(int delay)
 {
     auto timer = QSharedPointer<QTimer>::create();
-    return Async::start<void>([timer, delay](Async::Future<void> &future) {
+    return KAsync::start<void>([timer, delay](KAsync::Future<void> &future) {
         timer->setSingleShot(true);
         QObject::connect(timer.data(), &QTimer::timeout, [&future]() {
             future.setFinished();
diff --git a/async/src/async.h b/async/src/async.h
index b1f1121..152f98e 100644
--- a/async/src/async.h
+++ b/async/src/async.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2014  Daniel Vrátil <dvratil@redhat.com>
+ * 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
@@ -15,8 +15,10 @@
  * along with this library. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef ASYNC_H
-#define ASYNC_H
+#ifndef KASYNC_H
+#define KASYNC_H
+
+#include "kasync_export.h"
 
 #include <functional>
 #include <list>
@@ -64,7 +66,7 @@
  * 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 Async {
+namespace KAsync {
 
 template<typename PrevOut, typename Out, typename ... In>
 class Executor;
@@ -75,15 +77,15 @@ template<typename Out, typename ... In>
 class Job;
 
 template<typename Out, typename ... In>
-using ThenTask = typename detail::identity<std::function<void(In ..., Async::Future<Out>&)>>::type;
+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, Async::Future<Out>&)>>::type;
+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, Async::Future<Out>&)>>::type;
+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;
 
@@ -96,15 +98,15 @@ namespace Private
 class ExecutorBase;
 typedef QSharedPointer<ExecutorBase> ExecutorBasePtr;
 
-struct Execution {
+struct KASYNC_EXPORT Execution {
     Execution(const ExecutorBasePtr &executor);
     ~Execution();
     void setFinished();
 
     template<typename T>
-    Async::Future<T>* result() const
+    KAsync::Future<T>* result() const
     {
-        return static_cast<Async::Future<T>*>(resultBase);
+        return static_cast<KAsync::Future<T>*>(resultBase);
     }
 
     void releaseFuture();
@@ -125,16 +127,16 @@ struct Execution {
 
 typedef QSharedPointer<Execution> ExecutionPtr;
 
-class ExecutorBase
+class KASYNC_EXPORT ExecutorBase
 {
     template<typename PrevOut, typename Out, typename ... In>
     friend class Executor;
 
     template<typename Out, typename ... In>
-    friend class Async::Job;
+    friend class KAsync::Job;
 
     friend class Execution;
-    friend class Async::Tracer;
+    friend class KAsync::Tracer;
 
 public:
     virtual ~ExecutorBase();
@@ -144,7 +146,7 @@ protected:
     ExecutorBase(const ExecutorBasePtr &parent);
 
     template<typename T>
-    Async::Future<T>* createFuture(const ExecutionPtr &execution) const;
+    KAsync::Future<T>* createFuture(const ExecutionPtr &execution) const;
 
     virtual bool hasErrorFunc() const = 0;
     virtual bool handleError(const ExecutionPtr &execution) = 0;
@@ -193,7 +195,7 @@ public:
     void run(const ExecutionPtr &execution);
 private:
     EachTask<Out, In> mFunc;
-    QVector<Async::FutureWatcher<Out>*> mFutureWatchers;
+    QVector<KAsync::FutureWatcher<Out>*> mFutureWatchers;
 };
 
 template<typename Out, typename In>
@@ -234,8 +236,8 @@ public:
     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>
-    void run(Async::Future<Out> *future, const typename PrevOut::value_type &arg, std::true_type);  // std::is_void<Out>
+    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;
 };
 
@@ -244,11 +246,11 @@ private:
 /**
  * Start an asynchronous job sequence.
  *
- * Async::start() is your starting point to build a chain of jobs to be executed
+ * 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 Async::Future<In>,
+ *             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>
@@ -267,14 +269,14 @@ Job<ReturnType, Args ...> start();
  * 
  * The loop continues while @param condition returns true.
  */
-Job<void> dowhile(Condition condition, ThenTask<void> func);
+KASYNC_EXPORT Job<void> dowhile(Condition condition, ThenTask<void> func);
 
 /**
  * Async while loop.
  *
  * Loop continues while body returns true.
  */
-Job<void> dowhile(ThenTask<bool> body);
+KASYNC_EXPORT Job<void> dowhile(ThenTask<bool> body);
 
 /**
  * Iterate over a container.
@@ -287,7 +289,7 @@ Job<Out> iterate(const Out &container);
 /**
  * Async delay.
  */
-Job<void> wait(int delay);
+KASYNC_EXPORT Job<void> wait(int delay);
 
 /**
  * A null job.
@@ -307,7 +309,7 @@ Job<Out> null();
 template<typename Out>
 Job<Out> error(int errorCode = 1, const QString &errorMessage = QString());
 
-class JobBase
+class KASYNC_EXPORT JobBase
 {
     template<typename Out, typename ... In>
     friend class Job;
@@ -324,18 +326,18 @@ protected:
  * 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 Async::Future
+ * 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 Async::Future::waitForFinished() to wait for
+ * 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 Async::Future, and will execute the entire chain of jobs.
+ * @p KAsync::Future, and will execute the entire chain of jobs.
  *
  * @code
  * auto job = Job::start<QList<int>>(
- *     [](Async::Future<QList<int>> &future) {
+ *     [](KAsync::Future<QList<int>> &future) {
  *         MyREST::PendingUsers *pu = MyREST::requestListOfUsers();
  *         QObject::connect(pu, &PendingOperation::finished,
  *                          [&](PendingOperation *pu) {
@@ -344,7 +346,7 @@ protected:
  *                          });
  *      })
  * .each<QList<MyREST::User>, int>(
- *      [](const int &userId, Async::Future<QList<MyREST::User>> &future) {
+ *      [](const int &userId, KAsync::Future<QList<MyREST::User>> &future) {
  *          MyREST::PendingUser *pu = MyREST::requestUserDetails(userId);
  *          QObject::connect(pu, &PendingOperation::finished,
  *                           [&](PendingOperation *pu) {
@@ -353,7 +355,7 @@ protected:
  *                           });
  *      });
  *
- * Async::Future<QList<MyREST::User>> usersFuture = job.exec();
+ * KAsync::Future<QList<MyREST::User>> usersFuture = job.exec();
  * usersFuture.waitForFinished();
  * QList<MyRest::User> users = usersFuture.value();
  * @endcode
@@ -369,10 +371,10 @@ class Job : public JobBase
     friend class Job;
 
     template<typename OutOther, typename ... InOther>
-    friend Job<OutOther, InOther ...> start(Async::ThenTask<OutOther, InOther ...> func, ErrorHandler errorFunc);
+    friend Job<OutOther, InOther ...> start(KAsync::ThenTask<OutOther, InOther ...> func, ErrorHandler errorFunc);
 
     template<typename OutOther, typename ... InOther>
-    friend Job<OutOther, InOther ...> start(Async::SyncThenTask<OutOther, InOther ...> func, ErrorHandler errorFunc);
+    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>
@@ -454,7 +456,7 @@ public:
     }
 
     template<typename FirstIn>
-    Async::Future<Out> exec(FirstIn in)
+    KAsync::Future<Out> exec(FirstIn in)
     {
         // Inject a fake sync executor that will return the initial value
         Private::ExecutorBasePtr first = mExecutor;
@@ -474,10 +476,10 @@ public:
         return result;
     }
 
-    Async::Future<Out> exec()
+    KAsync::Future<Out> exec()
     {
         Private::ExecutionPtr execution = mExecutor->exec(mExecutor);
-        Async::Future<Out> result = *execution->result<Out>();
+        KAsync::Future<Out> result = *execution->result<Out>();
 
         return result;
     }
@@ -499,15 +501,15 @@ private:
     template<typename InOther>
     void reduceInvariants()
     {
-        static_assert(Async::detail::isIterable<Out>::value,
+        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 ..., Async::Future<OutOther>&)> nestedJobWrapper(Job<OutOther, InOther ...> otherJob) {
-        return [otherJob](InOther ... in, Async::Future<OutOther> &future) {
+    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>();
@@ -518,7 +520,7 @@ private:
                                  // in copyFutureValue()
                                  // copy by value is const
                                  auto outFuture = future;
-                                 Async::detail::copyFutureValue(watcher->future(), outFuture);
+                                 KAsync::detail::copyFutureValue(watcher->future(), outFuture);
                                  if (watcher->future().errorCode()) {
                                      outFuture.setError(watcher->future().errorCode(), watcher->future().errorMessage());
                                  } else {
@@ -531,12 +533,12 @@ private:
     }
 };
 
-} // namespace Async
+} // namespace KAsync
 
 
 // ********** Out of line definitions ****************
 
-namespace Async {
+namespace KAsync {
 
 template<typename Out, typename ... In>
 Job<Out, In ...> start(ThenTask<Out, In ...> func, ErrorHandler error)
@@ -557,7 +559,7 @@ template<typename ReturnType, typename KJobType, ReturnType (KJobType::*KJobResu
 Job<ReturnType, Args ...> start()
 {
     return Job<ReturnType, Args ...>(Private::ExecutorBasePtr(
-        new Private::ThenExecutor<ReturnType, Args ...>([](const Args & ... args, Async::Future<ReturnType> &future)
+        new Private::ThenExecutor<ReturnType, Args ...>([](const Args & ... args, KAsync::Future<ReturnType> &future)
             {
                 KJobType *job = new KJobType(args ...);
                 job->connect(job, &KJob::finished,
@@ -578,8 +580,8 @@ Job<ReturnType, Args ...> start()
 template<typename Out>
 Job<Out> null()
 {
-    return Async::start<Out>(
-        [](Async::Future<Out> &future) {
+    return KAsync::start<Out>(
+        [](KAsync::Future<Out> &future) {
             future.setFinished();
         });
 }
@@ -587,8 +589,8 @@ Job<Out> null()
 template<typename Out>
 Job<Out> error(int errorCode, const QString &errorMessage)
 {
-    return Async::start<Out>(
-        [errorCode, errorMessage](Async::Future<Out> &future) {
+    return KAsync::start<Out>(
+        [errorCode, errorMessage](KAsync::Future<Out> &future) {
             future.setError(errorCode, errorMessage);
         });
 }
@@ -596,7 +598,7 @@ Job<Out> error(int errorCode, const QString &errorMessage)
 template<typename Out>
 Job<Out> iterate(const Out &container)
 {
-    return Async::start<Out>(
+    return KAsync::start<Out>(
         [container]() {
             return container;
         });
@@ -606,9 +608,9 @@ Job<Out> iterate(const Out &container)
 namespace Private {
 
 template<typename T>
-Async::Future<T>* ExecutorBase::createFuture(const ExecutionPtr &execution) const
+KAsync::Future<T>* ExecutorBase::createFuture(const ExecutionPtr &execution) const
 {
-    return new Async::Future<T>(execution);
+    return new KAsync::Future<T>(execution);
 }
 
 template<typename PrevOut, typename Out, typename ... In>
@@ -625,8 +627,8 @@ ExecutionPtr Executor<PrevOut, Out, In ...>::exec(const ExecutorBasePtr &self)
     execution->prevExecution = mPrev ? mPrev->exec(mPrev) : ExecutionPtr();
 
     execution->resultBase = ExecutorBase::createFuture<Out>(execution);
-    auto fw = new Async::FutureWatcher<Out>();
-    QObject::connect(fw, &Async::FutureWatcher<Out>::futureReady,
+    auto fw = new KAsync::FutureWatcher<Out>();
+    QObject::connect(fw, &KAsync::FutureWatcher<Out>::futureReady,
                      [fw, execution, this]() {
                          handleError(execution);
                          execution->setFinished();
@@ -634,7 +636,7 @@ ExecutionPtr Executor<PrevOut, Out, In ...>::exec(const ExecutorBasePtr &self)
                      });
     fw->setFuture(*execution->result<Out>());
 
-    Async::Future<PrevOut> *prevFuture = execution->prevExecution ? execution->prevExecution->result<PrevOut>() : nullptr;
+    KAsync::Future<PrevOut> *prevFuture = execution->prevExecution ? execution->prevExecution->result<PrevOut>() : nullptr;
     if (!prevFuture || prevFuture->isFinished()) {
         if (prevFuture) { // prevFuture implies execution->prevExecution
             if (prevFuture->errorCode()) {
@@ -655,8 +657,8 @@ ExecutionPtr Executor<PrevOut, Out, In ...>::exec(const ExecutorBasePtr &self)
         execution->isRunning = true;
         run(execution);
     } else {
-        auto prevFutureWatcher = new Async::FutureWatcher<PrevOut>();
-        QObject::connect(prevFutureWatcher, &Async::FutureWatcher<PrevOut>::futureReady,
+        auto prevFutureWatcher = new KAsync::FutureWatcher<PrevOut>();
+        QObject::connect(prevFutureWatcher, &KAsync::FutureWatcher<PrevOut>::futureReady,
                          [prevFutureWatcher, execution, this]() {
                              auto prevFuture = prevFutureWatcher->future();
                              assert(prevFuture.isFinished());
@@ -679,7 +681,7 @@ ExecutionPtr Executor<PrevOut, Out, In ...>::exec(const ExecutorBasePtr &self)
                              run(execution);
                          });
 
-        prevFutureWatcher->setFuture(*static_cast<Async::Future<PrevOut>*>(prevFuture));
+        prevFutureWatcher->setFuture(*static_cast<KAsync::Future<PrevOut>*>(prevFuture));
     }
 
     return execution;
@@ -712,7 +714,7 @@ ThenExecutor<Out, In ...>::ThenExecutor(ThenTask<Out, In ...> then, ErrorHandler
 template<typename Out, typename ... In>
 void ThenExecutor<Out, In ...>::run(const ExecutionPtr &execution)
 {
-    Async::Future<typename detail::prevOut<In ...>::type> *prevFuture = nullptr;
+    KAsync::Future<typename detail::prevOut<In ...>::type> *prevFuture = nullptr;
     if (execution->prevExecution) {
         prevFuture = execution->prevExecution->result<typename detail::prevOut<In ...>::type>();
         assert(prevFuture->isFinished());
@@ -744,17 +746,17 @@ void EachExecutor<PrevOut, Out, In>::run(const ExecutionPtr &execution)
 
     for (auto arg : prevFuture->value()) {
         //We have to manually manage the lifetime of these temporary futures
-        Async::Future<Out> *future = new Async::Future<Out>();
+        KAsync::Future<Out> *future = new KAsync::Future<Out>();
         EachExecutor<PrevOut, Out, In>::mFunc(arg, *future);
-        auto fw = new Async::FutureWatcher<Out>();
+        auto fw = new KAsync::FutureWatcher<Out>();
         mFutureWatchers.append(fw);
-        QObject::connect(fw, &Async::FutureWatcher<Out>::futureReady,
+        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);
-                             Async::detail::aggregateFutureValue<Out>(fw->future(), *out);
+                             KAsync::detail::aggregateFutureValue<Out>(fw->future(), *out);
                              if (mFutureWatchers.isEmpty()) {
                                  out->setFinished();
                              }
@@ -794,19 +796,19 @@ void SyncThenExecutor<Out, In ...>::run(const ExecutionPtr &execution)
 template<typename Out, typename ... In>
 void SyncThenExecutor<Out, In ...>::run(const ExecutionPtr &execution, std::false_type)
 {
-    Async::Future<typename detail::prevOut<In ...>::type> *prevFuture =
+    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
-    Async::Future<Out> *future = execution->result<Out>();
+    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)
 {
-    Async::Future<typename detail::prevOut<In ...>::type> *prevFuture =
+    KAsync::Future<typename detail::prevOut<In ...>::type> *prevFuture =
         execution->prevExecution
             ? execution->prevExecution->result<typename detail::prevOut<In ...>::type>()
             : nullptr;
@@ -842,13 +844,13 @@ 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)
+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(Async::Future<Out> * /* unused */, const typename PrevOut::value_type &arg, std::true_type)
+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);
 }
@@ -863,10 +865,10 @@ SyncReduceExecutor<Out, In>::SyncReduceExecutor(SyncReduceTask<Out, In> reduce,
 
 } // namespace Private
 
-} // namespace Async
+} // namespace KAsync
 
 
 
-#endif // ASYNC_H
+#endif // KASYNC_H
 
 
diff --git a/async/src/async_impl.h b/async/src/async_impl.h
index 8c74193..5b4e393 100644
--- a/async/src/async_impl.h
+++ b/async/src/async_impl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2014  Daniel Vrátil <dvratil@redhat.com>
+ * 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
@@ -15,13 +15,13 @@
  * along with this library. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef ASYNC_IMPL_H
-#define ASYNC_IMPL_H
+#ifndef KASYNC_IMPL_H
+#define KASYNC_IMPL_H
 
 #include "async.h"
 #include <type_traits>
 
-namespace Async {
+namespace KAsync {
 
 namespace detail {
 
@@ -48,34 +48,34 @@ struct prevOut {
 
 template<typename T>
 inline typename std::enable_if<!std::is_void<T>::value, void>::type
-copyFutureValue(const Async::Future<T> &in, Async::Future<T> &out)
+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 Async::Future<T> &in, Async::Future<T> &out)
+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 Async::Future<T> &in, Async::Future<T> &out)
+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 Async::Future<T> &in, Async::Future<T> &out)
+aggregateFutureValue(const KAsync::Future<T> &in, KAsync::Future<T> &out)
 {
     // noop
 }
 
 } // namespace Detail
 
-} // namespace Async
+} // namespace KAsync
 
-#endif // ASYNC_IMPL_H
+#endif // KASYNC_IMPL_H
diff --git a/async/src/debug.cpp b/async/src/debug.cpp
index fdf2fa1..64a3a3b 100644
--- a/async/src/debug.cpp
+++ b/async/src/debug.cpp
@@ -25,7 +25,7 @@
 #include <memory>
 #endif
 
-namespace Async
+namespace KAsync
 {
 
 Q_LOGGING_CATEGORY(Debug, "org.kde.async", QtWarningMsg);
@@ -37,15 +37,15 @@ QString demangleName(const char *name)
     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());
+        return QString::fromLatin1(demangled.get());
     }
 #endif
-    return QString(name);
+    return QString::fromLatin1(name);
 }
 
 }
 
-using namespace Async;
+using namespace KAsync;
 
 int Tracer::lastId = 0;
 
@@ -53,12 +53,12 @@ Tracer::Tracer(Private::Execution *execution)
     : mId(lastId++)
     , mExecution(execution)
 {
-    msg(Async::Tracer::Start);
+    msg(KAsync::Tracer::Start);
 }
 
 Tracer::~Tracer()
 {
-    msg(Async::Tracer::End);
+    msg(KAsync::Tracer::End);
     // FIXME: Does this work on parallel executions?
     --lastId;
     --mId;
@@ -68,8 +68,8 @@ void Tracer::msg(Tracer::MsgType msgType)
 {
 #ifndef QT_NO_DEBUG
     qCDebug(Trace).nospace() << (QString().fill(QLatin1Char(' '), mId * 2) % 
-                                 (msgType == Async::Tracer::Start ? " START " : " END   ") %
-                                 QString::number(mId) % " " %
+                                 (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
index c453eb3..b2b2ff7 100644
--- a/async/src/debug.h
+++ b/async/src/debug.h
@@ -15,8 +15,10 @@
  * along with this library. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef ASYNC_DEBUG_H
-#define ASYNC_DEBUG_H
+#ifndef KASYNC_DEBUG_H
+#define KASYNC_DEBUG_H
+
+#include "kasync_export.h"
 
 #include <QLoggingCategory>
 #include <QStringBuilder>
@@ -25,20 +27,20 @@
 #include <typeinfo>
 #endif
 
-namespace Async
+namespace KAsync
 {
 
 Q_DECLARE_LOGGING_CATEGORY(Debug)
 Q_DECLARE_LOGGING_CATEGORY(Trace)
 
-QString demangleName(const char *name);
+KASYNC_EXPORT QString demangleName(const char *name);
 
 namespace Private
 {
 class Execution;
 }
 
-class Tracer
+class KASYNC_EXPORT Tracer
 {
 public:
     Tracer(Private::Execution *execution);
@@ -62,7 +64,7 @@ private:
 #ifndef QT_NO_DEBUG
     template<typename T>
     QString storeExecutorNameExpanded() {
-        return Async::demangleName(typeid(T).name());
+        return KAsync::demangleName(typeid(T).name());
     }
 
     template<typename T, typename ... Tail>
@@ -77,4 +79,4 @@ private:
     #define STORE_EXECUTOR_NAME(...)
 #endif
 
-#endif // ASYNC_DEBUG_H
\ No newline at end of file
+#endif // KASYNC_DEBUG_H
\ No newline at end of file
diff --git a/async/src/future.cpp b/async/src/future.cpp
index 4f3cd80..9281cc8 100644
--- a/async/src/future.cpp
+++ b/async/src/future.cpp
@@ -18,7 +18,7 @@
 #include "future.h"
 #include "async.h"
 
-using namespace Async;
+using namespace KAsync;
 
 FutureBase::PrivateBase::PrivateBase(const Private::ExecutionPtr &execution)
     : finished(false)
@@ -53,7 +53,7 @@ FutureBase::FutureBase(FutureBase::PrivateBase *dd)
 {
 }
 
-FutureBase::FutureBase(const Async::FutureBase &other)
+FutureBase::FutureBase(const KAsync::FutureBase &other)
     : d(other.d)
 {
 }
diff --git a/async/src/future.h b/async/src/future.h
index ff199ef..b2b723e 100644
--- a/async/src/future.h
+++ b/async/src/future.h
@@ -18,6 +18,8 @@
 #ifndef FUTURE_H
 #define FUTURE_H
 
+#include "kasync_export.h"
+
 class QEventLoop;
 
 #include <type_traits>
@@ -27,7 +29,7 @@ class QEventLoop;
 #include <QVector>
 #include <QEventLoop>
 
-namespace Async {
+namespace KAsync {
 
 class FutureWatcherBase;
 template<typename T>
@@ -40,9 +42,9 @@ class ExecutorBase;
 typedef QSharedPointer<Execution> ExecutionPtr;
 } // namespace Private
 
-class FutureBase
+class KASYNC_EXPORT FutureBase
 {
-    friend class Async::Private::Execution;
+    friend class KAsync::Private::Execution;
     friend class FutureWatcherBase;
 
 public:
@@ -61,7 +63,7 @@ protected:
     class PrivateBase : public QSharedData
     {
     public:
-        PrivateBase(const Async::Private::ExecutionPtr &execution);
+        PrivateBase(const KAsync::Private::ExecutionPtr &execution);
         virtual ~PrivateBase();
 
         void releaseExecution();
@@ -72,14 +74,14 @@ protected:
 
         QVector<QPointer<FutureWatcherBase>> watchers;
     private:
-        QWeakPointer<Async::Private::Execution> mExecution;
+        QWeakPointer<KAsync::Private::Execution> mExecution;
     };
 
     FutureBase();
     FutureBase(FutureBase::PrivateBase *dd);
     FutureBase(const FutureBase &other);
 
-    void addWatcher(Async::FutureWatcherBase *watcher);
+    void addWatcher(KAsync::FutureWatcherBase *watcher);
     void releaseExecution();
 
 protected:
@@ -105,14 +107,14 @@ public:
         }
         FutureWatcher<T> watcher;
         QEventLoop eventLoop;
-        QObject::connect(&watcher, &Async::FutureWatcher<T>::futureReady,
+        QObject::connect(&watcher, &KAsync::FutureWatcher<T>::futureReady,
                          &eventLoop, &QEventLoop::quit);
-        watcher.setFuture(*static_cast<const Async::Future<T>*>(this));
+        watcher.setFuture(*static_cast<const KAsync::Future<T>*>(this));
         eventLoop.exec();
     }
 
 protected:
-    FutureGeneric(const Async::Private::ExecutionPtr &execution)
+    FutureGeneric(const KAsync::Private::ExecutionPtr &execution)
         : FutureBase(new Private(execution))
     {}
 
@@ -124,7 +126,7 @@ protected:
     class Private : public FutureBase::PrivateBase
     {
     public:
-        Private(const Async::Private::ExecutionPtr &execution)
+        Private(const KAsync::Private::ExecutionPtr &execution)
             : FutureBase::PrivateBase(execution)
         {}
 
@@ -137,14 +139,14 @@ protected:
 template<typename T>
 class Future : public FutureGeneric<T>
 {
-    friend class Async::Private::ExecutorBase;
+    friend class KAsync::Private::ExecutorBase;
 
     template<typename T_>
-    friend class Async::FutureWatcher;
+    friend class KAsync::FutureWatcher;
 
 public:
     Future()
-        : FutureGeneric<T>(Async::Private::ExecutionPtr())
+        : FutureGeneric<T>(KAsync::Private::ExecutionPtr())
     {}
 
     Future(const Future<T> &other)
@@ -162,7 +164,7 @@ public:
     }
 
 protected:
-    Future(const Async::Private::ExecutionPtr &execution)
+    Future(const KAsync::Private::ExecutionPtr &execution)
         : FutureGeneric<T>(execution)
     {}
 
@@ -171,11 +173,11 @@ protected:
 template<>
 class Future<void> : public FutureGeneric<void>
 {
-    friend class Async::Private::ExecutorBase;
+    friend class KAsync::Private::ExecutorBase;
 
 public:
     Future()
-        : FutureGeneric<void>(Async::Private::ExecutionPtr())
+        : FutureGeneric<void>(KAsync::Private::ExecutionPtr())
     {}
 
     Future(const Future<void> &other)
@@ -183,7 +185,7 @@ public:
     {}
 
 protected:
-    Future(const Async::Private::ExecutionPtr &execution)
+    Future(const KAsync::Private::ExecutionPtr &execution)
         : FutureGeneric<void>(execution)
     {}
 };
@@ -192,7 +194,7 @@ protected:
 
 
 
-class FutureWatcherBase : public QObject
+class KASYNC_EXPORT FutureWatcherBase : public QObject
 {
     Q_OBJECT
 
@@ -209,12 +211,12 @@ protected:
     void futureReadyCallback();
     void futureProgressCallback(qreal progress);
 
-    void setFutureImpl(const Async::FutureBase &future);
+    void setFutureImpl(const KAsync::FutureBase &future);
 
 protected:
     class Private {
     public:
-        Async::FutureBase future;
+        KAsync::FutureBase future;
     };
 
     Private * const d;
@@ -226,7 +228,7 @@ private:
 template<typename T>
 class FutureWatcher : public FutureWatcherBase
 {
-    friend class Async::FutureGeneric<T>;
+    friend class KAsync::FutureGeneric<T>;
 
 public:
     FutureWatcher(QObject *parent = nullptr)
@@ -236,14 +238,14 @@ public:
     ~FutureWatcher()
     {}
 
-    void setFuture(const Async::Future<T> &future)
+    void setFuture(const KAsync::Future<T> &future)
     {
-        setFutureImpl(*static_cast<const Async::FutureBase*>(&future));
+        setFutureImpl(*static_cast<const KAsync::FutureBase*>(&future));
     }
 
-    Async::Future<T> future() const
+    KAsync::Future<T> future() const
     {
-        return *static_cast<Async::Future<T>*>(&d->future);
+        return *static_cast<KAsync::Future<T>*>(&d->future);
     }
 
 private: