3 files changed, 121 insertions, 89 deletions

diff --git a/async/src/.async.h.kate-swp b/async/src/.async.h.kate-swp
new file mode 100644
index 0000000..82f3ca1
--- /dev/null
+++ b/async/src/.async.h.kate-swp
diff --git a/async/src/async.cpp b/async/src/async.cpp
index 16da384..0b8d7f3 100644
--- a/async/src/async.cpp
+++ b/async/src/async.cpp
@@ -28,7 +28,19 @@
 
 using namespace Async;
 
-JobBase::JobBase(ExecutorBase *executor)
+Private::ExecutorBase::ExecutorBase(ExecutorBase* parent)
+    : mPrev(parent)
+    , mResult(0)
+{
+}
+
+Private::ExecutorBase::~ExecutorBase()
+{
+    delete mResult;
+}
+
+
+JobBase::JobBase(Private::ExecutorBase *executor)
     : mExecutor(executor)
 {
 }
diff --git a/async/src/async.h b/async/src/async.h
index 52d0570..66e455c 100644
--- a/async/src/async.h
+++ b/async/src/async.h
@@ -51,39 +51,30 @@ using EachTask = typename detail::identity<std::function<void(In, Async::Future<
 template<typename Out, typename In>
 using ReduceTask = typename detail::identity<std::function<void(In, Async::Future<Out>&)>>::type;
 
-template<typename Out, typename ... In>
-Job<Out, In ...> start(ThenTask<Out, In ...> func);
+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()
-    {
-        delete mResult;
-    }
-
+    virtual ~ExecutorBase();
     virtual void exec() = 0;
 
-    FutureBase* result() const
+    inline FutureBase* result() const
     {
         return mResult;
     }
 
 protected:
-    ExecutorBase(ExecutorBase *parent)
-      : mPrev(parent)
-      , mResult(0)
-    {
-    }
+    ExecutorBase(ExecutorBase *parent);
 
     ExecutorBase *mPrev;
     FutureBase *mResult;
@@ -95,20 +86,9 @@ class Executor : public ExecutorBase
 protected:
     Executor(ExecutorBase *parent)
         : ExecutorBase(parent)
-    {
-    }
-
-    Async::Future<PrevOut>* chainup()
-    {
-        if (mPrev) {
-            mPrev->exec();
-            auto future = static_cast<Async::Future<PrevOut>*>(mPrev->result());
-            assert(future->isFinished());
-            return future;
-        } else {
-            return 0;
-        }
-    }
+    {}
+    virtual ~Executor() {}
+    inline Async::Future<PrevOut>* chainup();
 
     std::function<void(const In& ..., Async::Future<Out> &)> mFunc;
 };
@@ -117,72 +97,28 @@ template<typename Out, typename ... In>
 class ThenExecutor: public Executor<typename PreviousOut<In ...>::type, Out, In ...>
 {
 public:
-    ThenExecutor(ThenTask<Out, In ...> then, ExecutorBase *parent = nullptr)
-        : Executor<typename     PreviousOut<In ...>::type, Out, In ...>(parent)
-    {
-        this->mFunc = then;
-    }
-
-    void 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;
-    }
+    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)
-        : Executor<PrevOut, Out, In>(parent)
-    {
-        this->mFunc = each;
-    }
-
-    void 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;
-    }
+    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)
-        : Executor<In, Out, In>(parent)
-    {
-        this->mFunc = reduce;
-    }
-
-    void exec()
-    {
-        auto in = this->chainup();
-
-        auto out = new Async::Future<Out>();
-        this->mFunc(in->value(), *out);
-        out->waitForFinished();
-        this->mResult = out;
-    }
+    ReduceExecutor(ReduceTask<Out, In> reduce, ExecutorBase *parent);
+    void exec();
 };
 
+} // namespace Private
+
 
 class JobBase
 {
@@ -190,13 +126,13 @@ class JobBase
     friend class Job;
 
 public:
-    JobBase(ExecutorBase *executor);
+    JobBase(Private::ExecutorBase *executor);
     ~JobBase();
 
     void exec();
 
 protected:
-    ExecutorBase *mExecutor;
+    Private::ExecutorBase *mExecutor;
 };
 
 template<typename Out, typename ... In>
@@ -212,7 +148,7 @@ public:
     template<typename OutOther, typename ... InOther>
     Job<OutOther, InOther ...> then(ThenTask<OutOther, InOther ...> func)
     {
-        return Job<OutOther, InOther ...>(new ThenExecutor<OutOther, InOther ...>(func, mExecutor));
+        return Job<OutOther, InOther ...>(new Private::ThenExecutor<OutOther, InOther ...>(func, mExecutor));
     }
 
     template<typename OutOther, typename InOther>
@@ -222,7 +158,7 @@ public:
                       "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 EachExecutor<Out, OutOther, InOther>(func, mExecutor));
+        return Job<OutOther, InOther>(new Private::EachExecutor<Out, OutOther, InOther>(func, mExecutor));
     }
 
     template<typename OutOther, typename InOther>
@@ -232,7 +168,7 @@ public:
                       "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 ReduceExecutor<OutOther, InOther>(func, mExecutor));
+        return Job<OutOther, InOther>(new Private::ReduceExecutor<OutOther, InOther>(func, mExecutor));
     }
 
     Async::Future<Out> result() const
@@ -241,7 +177,7 @@ public:
     }
 
 private:
-    Job(ExecutorBase *executor)
+    Job(Private::ExecutorBase *executor)
         : JobBase(executor)
     {
     }
@@ -252,12 +188,96 @@ private:
 
 // ********** Out of line definitions ****************
 
+namespace Async {
+
 template<typename Out, typename ... In>
-Async::Job<Out, In ...> Async::start(ThenTask<Out, In ...> func)
+Job<Out, In ...> start(ThenTask<Out, In ...> func)
 {
-    return Job<Out, In ...>(new ThenExecutor<Out, In ...>(func));
+    return Job<Out, In ...>(new Private::ThenExecutor<Out, In ...>(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