Moved generic part of load to GenericFacade

1 files changed, 45 insertions, 0 deletions

diff --git a/common/facade.h b/common/facade.h
index f9b5a83..6c1ad67 100644
--- a/common/facade.h
+++ b/common/facade.h
@@ -29,6 +29,7 @@
 #include "createentity_generated.h"
 #include "domainadaptor.h"
 #include "entitybuffer.h"
+#include "log.h"
 
 /**
  * A QueryRunner runs a query and updates the corresponding result set.
@@ -98,6 +99,48 @@ public:
     {
     }
 
+    //TODO JOBAPI return job from sync continuation to execute it as subjob?
+    Async::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > &resultProvider) Q_DECL_OVERRIDE
+    {
+        auto runner = QSharedPointer<QueryRunner>::create(query);
+        QWeakPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > weakResultProvider = resultProvider;
+        runner->setQuery([this, weakResultProvider, query] (qint64 oldRevision, qint64 newRevision) -> Async::Job<qint64> {
+            return Async::start<qint64>([this, weakResultProvider, query](Async::Future<qint64> &future) {
+                auto resultProvider = weakResultProvider.toStrongRef();
+                if (!resultProvider) {
+                    Warning() << "Tried executing query after result provider is already gone";
+                    future.setError(0, QString());
+                    future.setFinished();
+                    return;
+                }
+                //TODO only emit changes and don't replace everything
+                resultProvider->clear();
+                //rerun query
+                auto addCallback = std::bind(&Akonadi2::ResultProvider<typename DomainType::Ptr>::add, resultProvider, std::placeholders::_1);
+                load(query, addCallback).template then<void, qint64>([resultProvider, &future](qint64 queriedRevision) {
+                    //TODO set revision in result provider?
+                    //TODO update all existing results with new revision
+                    resultProvider->complete();
+                    future.setValue(queriedRevision);
+                    future.setFinished();
+                }).exec();
+            });
+        });
+
+        //In case of a live query we keep the runner for as long alive as the result provider exists
+        if (query.liveQuery) {
+            resultProvider->setQueryRunner(runner);
+            QObject::connect(mResourceAccess.data(), &Akonadi2::ResourceAccess::revisionChanged, runner.data(), &QueryRunner::revisionChanged);
+        }
+
+        //We have to capture the runner to keep it alive
+        return synchronizeResource(query.syncOnDemand, query.processAll).template then<void>([runner](Async::Future<void> &future) {
+            runner->run().then<void>([&future]() {
+                future.setFinished();
+            }).exec();
+        });
+    }
+
 protected:
     Async::Job<void> sendCreateCommand(const QByteArray &t, const QByteArray &buffer)
     {
@@ -129,6 +172,8 @@ protected:
         return Async::null<void>();
     }
 
+    virtual Async::Job<qint64> load(const Akonadi2::Query &query, const std::function<void(const typename DomainType::Ptr &)> &resultCallback) { return Async::null<qint64>(); };
+
 protected:
     //TODO use one resource access instance per application => make static
     QSharedPointer<Akonadi2::ResourceAccess> mResourceAccess;