8 files changed, 731 insertions, 0 deletions

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