Async: move as much Future code as possible from public header to .cpp

1 files changed, 82 insertions, 10 deletions

diff --git a/async/src/future.cpp b/async/src/future.cpp
index 50a326a..970060b 100644
--- a/async/src/future.cpp
+++ b/async/src/future.cpp
@@ -20,11 +20,41 @@
 
 using namespace Async;
 
+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 Async::FutureBase &other)
+    : d(other.d)
 {
 }
 
@@ -32,35 +62,77 @@ FutureBase::~FutureBase()
 {
 }
 
-FutureBase::PrivateBase::PrivateBase(const Private::ExecutionPtr &execution)
-    : mExecution(execution)
+void FutureBase::releaseExecution()
 {
+    d->releaseExecution();
 }
 
-FutureBase::PrivateBase::~PrivateBase()
+void FutureBase::setFinished()
 {
-    Private::ExecutionPtr executionPtr = mExecution.toStrongRef();
-    if (executionPtr) {
-        executionPtr->releaseFuture();
-        releaseExecution();
+    if (isFinished()) {
+        return;
+    }
+    d->finished = true;
+    for (auto watcher : d->watchers) {
+        if (watcher) {
+            watcher->futureReadyCallback();
+        }
     }
 }
 
-void FutureBase::PrivateBase::releaseExecution()
+bool FutureBase::isFinished() const
 {
-    mExecution.clear();
+    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::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();
+}
 
-#include "future.moc"
+void FutureWatcherBase::setFutureImpl(const FutureBase &future)
+{
+    d->future = future;
+    d->future.addWatcher(this);
+    if (future.isFinished()) {
+        futureReadyCallback();
+    }
+}