13 files changed, 786 insertions, 10 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c5b2eb4..3f86163 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -36,7 +36,7 @@ endfunction(generate_flatbuffers)
 
 set(CMAKE_AUTOMOC ON)
 add_definitions("-Wall -std=c++0x")
-include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
+include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} ${FLATBUFFERS_INCLUDE_DIR})
 
 configure_file(hawd.conf hawd.conf)
 
@@ -55,4 +55,7 @@ add_subdirectory(dummyresource)
 # some tests
 add_subdirectory(tests)
 
+# async library prototype
+add_subdirectory(async)
+
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/async/CMakeLists.txt b/async/CMakeLists.txt
new file mode 100644
index 0000000..19ac407
--- /dev/null
+++ b/async/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_subdirectory(src)
+add_subdirectory(autotests)
\ No newline at end of file
diff --git a/async/autotests/CMakeLists.txt b/async/autotests/CMakeLists.txt
new file mode 100644
index 0000000..a2bedc8
--- /dev/null
+++ b/async/autotests/CMakeLists.txt
@@ -0,0 +1,5 @@
+include_directories(../src ${CMAKE_CURRENT_BINARY_DIR})
+
+add_executable(asynctest asynctest.cpp)
+qt5_use_modules(asynctest Test)
+target_link_libraries(asynctest akonadi2async Qt5::Core Qt5::Test)
\ No newline at end of file
diff --git a/async/autotests/asynctest.cpp b/async/autotests/asynctest.cpp
new file mode 100644
index 0000000..7aedfc4
--- /dev/null
+++ b/async/autotests/asynctest.cpp
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2014  Daniel Vrátil <dvratil@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License or (at your option) version 3 or any later version
+ * accepted by the membership of KDE e.V. (or its successor approved
+ * by the membership of KDE e.V.), which shall act as a proxy
+ * defined in Section 14 of version 3 of the license.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "../src/async.h"
+
+#include <QObject>
+#include <QString>
+#include <QTimer>
+#include <QtTest/QTest>
+
+class AsyncTest : public QObject
+{
+    Q_OBJECT
+
+public:
+    AsyncTest()
+    {}
+
+    ~AsyncTest()
+    {}
+
+private Q_SLOTS:
+    void testSyncPromises();
+    void testAsyncPromises();
+    void testSyncEach();
+    void testSyncReduce();
+};
+
+void AsyncTest::testSyncPromises()
+{
+    auto baseJob = Async::start<int>(
+        [](Async::Future<int> &f) {
+            f.setValue(42);
+            f.setFinished();
+        })
+    .then<QString, int>(
+        [](int v, Async::Future<QString> &f) {
+            f.setValue("Result is " + QString::number(v));
+            f.setFinished();
+        });
+
+    auto job = baseJob.then<QString, QString>(
+        [](const QString &v, Async::Future<QString> &f) {
+            f.setValue(v.toUpper());
+            f.setFinished();
+        });
+
+    job.exec();
+    Async::Future<QString> future = job.result();
+
+    QVERIFY(future.isFinished());
+    QCOMPARE(future.value(), QString::fromLatin1("RESULT IS 42"));
+}
+
+void AsyncTest::testAsyncPromises()
+{
+    auto job = Async::start<int>(
+        [](Async::Future<int> &future) {
+            QTimer *timer = new QTimer();
+            QObject::connect(timer, &QTimer::timeout,
+                             [&]() {
+                                future.setValue(42);
+                                future.setFinished();
+                             });
+            QObject::connect(timer, &QTimer::timeout,
+                             timer, &QObject::deleteLater);
+            timer->setSingleShot(true);
+            timer->start(200);
+        });
+
+    job.exec();
+    Async::Future<int> future = job.result();
+    QVERIFY(future.isFinished());
+    QCOMPARE(future.value(), 42);
+}
+
+void AsyncTest::testSyncEach()
+{
+    auto job = Async::start<QList<int>>(
+        [](Async::Future<QList<int>> &future) {
+            future.setValue(QList<int>{ 1, 2, 3, 4 });
+            future.setFinished();
+        })
+    .each<QList<int>, int>(
+        [](const int &v, Async::Future<QList<int>> &future) {
+            future.setValue(QList<int>{ v + 1 });
+            future.setFinished();
+        });
+
+    job.exec();
+    Async::Future<QList<int>> future = job.result();
+    const QList<int> expected({ 2, 3, 4, 5 });
+    QVERIFY(future.isFinished());
+    QCOMPARE(future.value(), expected);
+}
+
+void AsyncTest::testSyncReduce()
+{
+    auto job = Async::start<QList<int>>(
+        [](Async::Future<QList<int>> &future) {
+            future.setValue(QList<int>{ 1, 2, 3, 4 });
+            future.setFinished();
+        })
+    .reduce<int, QList<int>>(
+        [](const QList<int> &list, Async::Future<int> &future) {
+            int sum = 0;
+            for (int i : list) sum += i;
+            future.setValue(sum);
+            future.setFinished();
+        });
+
+    job.exec();
+    Async::Future<int> future = job.result();
+    QVERIFY(future.isFinished());
+    QCOMPARE(future.value(), 10);
+}
+
+
+
+QTEST_MAIN(AsyncTest);
+
+#include "asynctest.moc"
diff --git a/async/src/CMakeLists.txt b/async/src/CMakeLists.txt
new file mode 100644
index 0000000..a98d8ce
--- /dev/null
+++ b/async/src/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(async_SRCS
+    async.cpp
+)
+
+add_library(akonadi2async SHARED ${async_SRCS})
+target_link_libraries(akonadi2async Qt5::Core)
diff --git a/async/src/async.cpp b/async/src/async.cpp
new file mode 100644
index 0000000..0b8d7f3
--- /dev/null
+++ b/async/src/async.cpp
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2014  Daniel Vrátil <dvratil@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License or (at your option) version 3 or any later version
+ * accepted by the membership of KDE e.V. (or its successor approved
+ * by the membership of KDE e.V.), which shall act as a proxy
+ * defined in Section 14 of version 3 of the license.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "async.h"
+
+#include <QCoreApplication>
+#include <QDebug>
+#include <QEventLoop>
+
+
+using namespace Async;
+
+Private::ExecutorBase::ExecutorBase(ExecutorBase* parent)
+    : mPrev(parent)
+    , mResult(0)
+{
+}
+
+Private::ExecutorBase::~ExecutorBase()
+{
+    delete mResult;
+}
+
+
+JobBase::JobBase(Private::ExecutorBase *executor)
+    : mExecutor(executor)
+{
+}
+
+JobBase::~JobBase()
+{
+}
+
+void JobBase::exec()
+{
+    mExecutor->exec();
+}
+
+
+FutureBase::FutureBase()
+    : mFinished(false)
+    , mWaitLoop(nullptr)
+{
+}
+
+FutureBase::FutureBase(const Async::FutureBase &other)
+    : mFinished(other.mFinished)
+    , mWaitLoop(other.mWaitLoop)
+{
+}
+
+FutureBase::~FutureBase()
+{
+}
+
+void FutureBase::setFinished()
+{
+    mFinished = true;
+    if (mWaitLoop && mWaitLoop->isRunning()) {
+        mWaitLoop->quit();
+    }
+}
+
+bool FutureBase::isFinished() const
+{
+    return mFinished;
+}
+
+void FutureBase::waitForFinished()
+{
+    if (mFinished) {
+        return;
+    }
+
+    mWaitLoop = new QEventLoop;
+    mWaitLoop->exec(QEventLoop::ExcludeUserInputEvents);
+    delete mWaitLoop;
+    mWaitLoop = 0;
+}
+
diff --git a/async/src/async.h b/async/src/async.h
new file mode 100644
index 0000000..0e4f246
--- /dev/null
+++ b/async/src/async.h
@@ -0,0 +1,337 @@
+/*
+ * Copyright 2014  Daniel Vrátil <dvratil@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License or (at your option) version 3 or any later version
+ * accepted by the membership of KDE e.V. (or its successor approved
+ * by the membership of KDE e.V.), which shall act as a proxy
+ * defined in Section 14 of version 3 of the license.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ASYNC_H
+#define ASYNC_H
+
+#include <functional>
+#include <list>
+#include <type_traits>
+#include <iostream>
+#include <cassert>
+#include <iterator>
+#include <boost/graph/graph_concepts.hpp>
+
+#include "future.h"
+#include "async_impl.h"
+
+
+namespace Async {
+
+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 ..., Async::Future<Out>&)>>::type;
+template<typename Out, typename In>
+using EachTask = typename detail::identity<std::function<void(In, Async::Future<Out>&)>>::type;
+template<typename Out, typename In>
+using ReduceTask = typename detail::identity<std::function<void(In, Async::Future<Out>&)>>::type;
+
+namespace Private
+{
+
+template<typename ... T>
+struct PreviousOut {
+    using type = typename std::tuple_element<0, std::tuple<T ..., void>>::type;
+};
+
+class ExecutorBase
+{
+    template<typename PrevOut, typename Out, typename ... In>
+    friend class Executor;
+
+public:
+    virtual ~ExecutorBase();
+    virtual void exec() = 0;
+
+    inline FutureBase* result() const
+    {
+        return mResult;
+    }
+
+protected:
+    ExecutorBase(ExecutorBase *parent);
+
+    ExecutorBase *mPrev;
+    FutureBase *mResult;
+};
+
+template<typename PrevOut, typename Out, typename ... In>
+class Executor : public ExecutorBase
+{
+protected:
+    Executor(ExecutorBase *parent)
+        : ExecutorBase(parent)
+    {}
+    virtual ~Executor() {}
+    inline Async::Future<PrevOut>* chainup();
+
+    std::function<void(const In& ..., Async::Future<Out> &)> mFunc;
+};
+
+template<typename Out, typename ... In>
+class ThenExecutor: public Executor<typename PreviousOut<In ...>::type, Out, In ...>
+{
+public:
+    ThenExecutor(ThenTask<Out, In ...> then, ExecutorBase *parent = nullptr);
+    void exec();
+};
+
+template<typename PrevOut, typename Out, typename In>
+class EachExecutor : public Executor<PrevOut, Out, In>
+{
+public:
+    EachExecutor(EachTask<Out, In> each, ExecutorBase *parent);
+    void exec();
+};
+
+template<typename Out, typename In>
+class ReduceExecutor : public Executor<In, Out, In>
+{
+public:
+    ReduceExecutor(ReduceTask<Out, In> reduce, ExecutorBase *parent);
+    void exec();
+};
+
+} // namespace Private
+
+/**
+ * Start an asynchronous job sequence.
+ *
+ * Async::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>,
+ *             where @p In is type of the result.
+ */
+template<typename Out>
+Job<Out> start(ThenTask<Out> func);
+
+class JobBase
+{
+    template<typename Out, typename ... In>
+    friend class Job;
+
+public:
+    JobBase(Private::ExecutorBase *executor);
+    ~JobBase();
+
+    void exec();
+
+protected:
+    Private::ExecutorBase *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 Async::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
+ * 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.
+ *
+ * @code
+ * auto job = Job::start<QList<int>>(
+ *     [](Async::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, Async::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();
+ *                           });
+ *      });
+ *
+ * Async::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>
+    friend Job<OutOther> start(Async::ThenTask<OutOther> func);
+
+public:
+    template<typename OutOther, typename ... InOther>
+    Job<OutOther, InOther ...> then(ThenTask<OutOther, InOther ...> func)
+    {
+        return Job<OutOther, InOther ...>(new Private::ThenExecutor<OutOther, InOther ...>(func, mExecutor));
+    }
+
+    template<typename OutOther, typename InOther>
+    Job<OutOther, InOther> each(EachTask<OutOther, InOther> func)
+    {
+        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(detail::isIterable<OutOther>::value,
+                      "The result type of 'Each' task must be a list or an array.");
+        return Job<OutOther, InOther>(new Private::EachExecutor<Out, OutOther, InOther>(func, mExecutor));
+    }
+
+    template<typename OutOther, typename InOther>
+    Job<OutOther, InOther> reduce(ReduceTask<OutOther, InOther> func)
+    {
+        static_assert(Async::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");
+        return Job<OutOther, InOther>(new Private::ReduceExecutor<OutOther, InOther>(func, mExecutor));
+    }
+
+    Async::Future<Out> result() const
+    {
+        return *static_cast<Async::Future<Out>*>(mExecutor->result());
+    }
+
+private:
+    Job(Private::ExecutorBase *executor)
+        : JobBase(executor)
+    {
+    }
+};
+
+} // namespace Async
+
+
+// ********** Out of line definitions ****************
+
+namespace Async {
+
+template<typename Out>
+Job<Out> start(ThenTask<Out> func)
+{
+    return Job<Out>(new Private::ThenExecutor<Out>(func));
+}
+
+namespace Private {
+
+template<typename PrevOut, typename Out, typename ... In>
+Future<PrevOut>* Executor<PrevOut, Out, In ...>::chainup()
+{
+    if (mPrev) {
+        mPrev->exec();
+        auto future = static_cast<Async::Future<PrevOut>*>(mPrev->result());
+        assert(future->isFinished());
+        return future;
+    } else {
+        return 0;
+    }
+}
+
+template<typename Out, typename ... In>
+ThenExecutor<Out, In ...>::ThenExecutor(ThenTask<Out, In ...> then, ExecutorBase* parent)
+    : Executor<typename PreviousOut<In ...>::type, Out, In ...>(parent)
+{
+    this->mFunc = then;
+}
+
+template<typename Out, typename ... In>
+void ThenExecutor<Out, In ...>::exec()
+{
+    auto in = this->chainup();
+    (void)in; // supress 'unused variable' warning when In is void
+
+    auto out = new Async::Future<Out>();
+    this->mFunc(in ? in->value() : In() ..., *out);
+    out->waitForFinished();
+    this->mResult = out;
+}
+
+template<typename PrevOut, typename Out, typename In>
+EachExecutor<PrevOut, Out, In>::EachExecutor(EachTask<Out, In> each, ExecutorBase* parent)
+    : Executor<PrevOut, Out, In>(parent)
+{
+    this->mFunc = each;
+}
+
+template<typename PrevOut, typename Out, typename In>
+void EachExecutor<PrevOut, Out, In>::exec()
+{
+    auto in = this->chainup();
+
+    auto *out = new Async::Future<Out>();
+    for (auto arg : in->value()) {
+        Async::Future<Out> future;
+        this->mFunc(arg, future);
+        future.waitForFinished();
+        out->setValue(out->value() + future.value());
+    }
+    out->setFinished();
+
+    this->mResult = out;
+}
+
+template<typename Out, typename In>
+ReduceExecutor<Out, In>::ReduceExecutor(ReduceTask<Out, In> reduce, ExecutorBase* parent)
+    : Executor<In, Out, In>(parent)
+{
+    this->mFunc = reduce;
+}
+
+template<typename Out, typename In>
+void ReduceExecutor<Out, In>::exec()
+{
+    auto in = this->chainup();
+
+    auto out = new Async::Future<Out>();
+    this->mFunc(in->value(), *out);
+    out->waitForFinished();
+    this->mResult = out;
+}
+
+} // namespace Private
+
+} // namespace Async
+
+
+
+#endif // ASYNC_H
+
+
diff --git a/async/src/async_impl.h b/async/src/async_impl.h
new file mode 100644
index 0000000..7b5c140
--- /dev/null
+++ b/async/src/async_impl.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2014  Daniel Vrátil <dvratil@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License or (at your option) version 3 or any later version
+ * accepted by the membership of KDE e.V. (or its successor approved
+ * by the membership of KDE e.V.), which shall act as a proxy
+ * defined in Section 14 of version 3 of the license.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef ASYNC_IMPL_H
+#define ASYNC_IMPL_H
+
+#include "async.h"
+
+namespace Async {
+
+namespace detail {
+
+template<typename T>
+struct identity
+{
+    typedef T type;
+};
+
+template<typename T, typename Enable = void>
+struct isIterable {
+    enum { value = 0 };
+};
+
+template<typename T>
+struct isIterable<T, typename std::conditional<false, typename T::iterator, void>::type> {
+    enum { value = 1 };
+};
+
+} // namespace Detail
+
+} // namespace Async
+
+#endif // ASYNC_IMPL_H
diff --git a/async/src/future.h b/async/src/future.h
new file mode 100644
index 0000000..eb3de1e
--- /dev/null
+++ b/async/src/future.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2014  Daniel Vrátil <dvratil@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License or (at your option) version 3 or any later version
+ * accepted by the membership of KDE e.V. (or its successor approved
+ * by the membership of KDE e.V.), which shall act as a proxy
+ * defined in Section 14 of version 3 of the license.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef FUTURE_H
+#define FUTURE_H
+
+class QEventLoop;
+
+namespace Async {
+
+class FutureBase
+{
+public:
+    FutureBase();
+    FutureBase(const FutureBase &other);
+    virtual ~FutureBase();
+
+    void setFinished();
+    bool isFinished() const;
+    void waitForFinished();
+
+protected:
+    bool mFinished;
+    QEventLoop *mWaitLoop;
+};
+
+template<typename T>
+class Future : public FutureBase
+{
+public:
+    Future()
+        : FutureBase()
+    {}
+
+    Future(const Future<T> &other)
+        : FutureBase(other)
+        , mValue(other.mValue)
+    {}
+
+    Future(const T &val)
+        : FutureBase()
+        , mValue(val)
+    {}
+
+    void setValue(const T &val)
+    {
+        mValue = val;
+    }
+
+    T value() const
+    {
+        return mValue;
+    }
+
+private:
+    T mValue;
+};
+
+template<>
+class Future<void> : public FutureBase
+{
+public:
+    Future()
+        : FutureBase()
+    {}
+
+    Future(const Future<void> &other)
+        : FutureBase(other)
+    {}
+};
+
+} // namespace Async
+
+#endif // FUTURE_H
diff --git a/client/clientapi.h b/client/clientapi.h
index 592fa48..662f96c 100644
--- a/client/clientapi.h
+++ b/client/clientapi.h
@@ -6,6 +6,7 @@
 #include <QStandardPaths>
 #include <QTimer>
 #include <QDebug>
+#include <QEventLoop>
 #include <functional>
 
 namespace async {
@@ -64,6 +65,14 @@ namespace async {
     * The future side for the client.
     *
     * It does not directly hold the state.
+    *
+    * The advantage of this is that we can specialize it to:
+    * * do inline transformations to the data
+    * * directly store the state in a suitable datastructure: QList, QSet, std::list, QVector, ...
+    * * build async interfaces with signals
+    * * build sync interfaces that block when accessing the value
+    *
+    * TODO: This should probably be merged with daniels futurebase used in Async
     */
     template<class DomainType>
     class ResultEmitter {
@@ -85,6 +94,42 @@ namespace async {
         std::function<void(void)> completeHandler;
     };
 
+
+    /*
+     * A result set specialization that provides a syncronous list
+     */
+    template<class T>
+    class SyncListResult : public QList<T> {
+    public:
+        SyncListResult(const QSharedPointer<ResultEmitter<T> > &emitter)
+            :QList<T>(),
+            mComplete(false),
+            mEmitter(emitter)
+        {
+            emitter->onAdded([this](const T &value) {
+                this->append(value);
+            });
+            emitter->onComplete([this]() {
+                mComplete = true;
+                auto loop = mWaitLoop.toStrongRef();
+                if (loop) {
+                    loop->quit();
+                }
+            });
+        }
+
+        void exec()
+        {
+            auto loop = QSharedPointer<QEventLoop>::create();
+            mWaitLoop = loop;
+            loop->exec(QEventLoop::ExcludeUserInputEvents);
+        }
+
+    private:
+        bool mComplete;
+        QWeakPointer<QEventLoop> mWaitLoop;
+        QSharedPointer<ResultEmitter<T> > mEmitter;
+    };
 }
 
 namespace Akonadi2 {
diff --git a/client/test/clientapitest.cpp b/client/test/clientapitest.cpp
index bff910b..2d1c238 100644
--- a/client/test/clientapitest.cpp
+++ b/client/test/clientapitest.cpp
@@ -37,15 +37,9 @@ private Q_SLOTS:
         Akonadi2::Query query;
         query.resources << "dummyresource";
 
-        auto result = Akonadi2::Store::load<Akonadi2::Domain::Event>(query);
-
-        QList<Akonadi2::Domain::Event::Ptr> resultSet;
-        result->onAdded([&resultSet](const Akonadi2::Domain::Event::Ptr &event){ resultSet << event; qDebug() << "result added";});
-
-        bool complete;
-        result->onComplete([&complete]{ complete = true; qDebug() << "complete";});
-
-        QTRY_VERIFY(complete);
+        async::SyncListResult<Akonadi2::Domain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::Domain::Event>(query));
+        result.exec();
+        QCOMPARE(result.size(), 1);
     }
 
 };
diff --git a/common/storage.h b/common/storage.h
index a051043..3f14e83 100644
--- a/common/storage.h
+++ b/common/storage.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <functional>
 #include <QString>
 
 class Storage {
diff --git a/tests/hawd/module.h b/tests/hawd/module.h
index 856c09c..4242cfe 100644
--- a/tests/hawd/module.h
+++ b/tests/hawd/module.h
@@ -21,6 +21,8 @@
 
 #include "state.h"
 
+#include <functional>
+
 #include <QStringList>
 #include <QVector>