A way to ensure all messages have been processed.

As queries become reactive this should become less important. We can then just wait until
all results become available. For tests it is in either case useful though.

4 files changed, 13 insertions, 5 deletions

diff --git a/dummyresource/facade.cpp b/dummyresource/facade.cpp
index 1aaec68..fcce871 100644
--- a/dummyresource/facade.cpp
+++ b/dummyresource/facade.cpp
@@ -115,16 +115,16 @@ static std::function<bool(const std::string &key, DummyEvent const *buffer, Akon
     return preparedQuery;
 }
 
-Async::Job<void> DummyResourceFacade::synchronizeResource(bool sync)
+Async::Job<void> DummyResourceFacade::synchronizeResource(bool sync, bool processAll)
 {
     //TODO check if a sync is necessary
     //TODO Only sync what was requested
     //TODO timeout
 
-    if (sync) {
+    if (sync || processAll) {
         return Async::start<void>([=](Async::Future<void> &future) {
             mResourceAccess->open();
-            mResourceAccess->synchronizeResource().then<void>([&future](Async::Future<void> &f) {
+            mResourceAccess->synchronizeResource(sync, processAll).then<void>([&future](Async::Future<void> &f) {
                 future.setFinished();
                 f.setFinished();
             }).exec();
@@ -195,7 +195,7 @@ void DummyResourceFacade::readValue(QSharedPointer<Akonadi2::Storage> storage, c
 
 Async::Job<void> DummyResourceFacade::load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback)
 {
-    return synchronizeResource(query.syncOnDemand).then<void>([=](Async::Future<void> &future) {
+    return synchronizeResource(query.syncOnDemand, query.processAll).then<void>([=](Async::Future<void> &future) {
         //Now that the sync is complete we can execute the query
         const auto preparedQuery = prepareQuery(query);
 
diff --git a/dummyresource/facade.h b/dummyresource/facade.h
index c9c8047..1f69161 100644
--- a/dummyresource/facade.h
+++ b/dummyresource/facade.h
@@ -44,7 +44,7 @@ public:
 
 private:
     void readValue(QSharedPointer<Akonadi2::Storage> storage, const QByteArray &key, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback, std::function<bool(const std::string &key, DummyCalendar::DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local)>);
-    Async::Job<void> synchronizeResource(bool sync);
+    Async::Job<void> synchronizeResource(bool sync, bool processAll);
     QSharedPointer<Akonadi2::ResourceAccess> mResourceAccess;
     QSharedPointer<DomainTypeAdaptorFactory<Akonadi2::Domain::Event, Akonadi2::Domain::Buffer::Event, DummyCalendar::DummyEvent> > mFactory;
 };
diff --git a/dummyresource/resourcefactory.cpp b/dummyresource/resourcefactory.cpp
index 18083cb..f510cd5 100644
--- a/dummyresource/resourcefactory.cpp
+++ b/dummyresource/resourcefactory.cpp
@@ -387,7 +387,14 @@ Async::Job<void> DummyResource::synchronizeWithSource(Akonadi2::Pipeline *pipeli
             }
         }
         //TODO find items to remove
+        qDebug() << "sync complete";
+        f.setFinished();
+    });
+}
 
+Async::Job<void> DummyResource::processAllMessages()
+{
+    return Async::start<void>([this](Async::Future<void> &f) {
         //We have to wait for all items to be processed to ensure the synced items are available when a query gets executed.
         //TODO: report errors while processing sync?
         if (mSynchronizerQueue.isEmpty()) {
diff --git a/dummyresource/resourcefactory.h b/dummyresource/resourcefactory.h
index 767eba1..3b99d5e 100644
--- a/dummyresource/resourcefactory.h
+++ b/dummyresource/resourcefactory.h
@@ -35,6 +35,7 @@ class DummyResource : public Akonadi2::Resource
 public:
     DummyResource();
     Async::Job<void> synchronizeWithSource(Akonadi2::Pipeline *pipeline);
+    Async::Job<void> processAllMessages();
     void processCommand(int commandId, const QByteArray &data, uint size, Akonadi2::Pipeline *pipeline);
     void configurePipeline(Akonadi2::Pipeline *pipeline);
     int error() const;