3 files changed, 127 insertions, 142 deletions

diff --git a/common/facade.h b/common/facade.h
index d9ec0c9..e32ee96 100644
--- a/common/facade.h
+++ b/common/facade.h
@@ -31,6 +31,8 @@
 #include "domainadaptor.h"
 #include "entitybuffer.h"
 #include "log.h"
+#include "storage.h"
+#include "resultset.h"
 
 /**
  * A QueryRunner runs a query and updates the corresponding result set.
@@ -107,7 +109,8 @@ public:
     GenericFacade(const QByteArray &resourceIdentifier, const QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > &adaptorFactory = QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> >())
         : Akonadi2::StoreFacade<DomainType>(),
         mResourceAccess(new ResourceAccess(resourceIdentifier)),
-        mDomainTypeAdaptorFactory(adaptorFactory)
+        mDomainTypeAdaptorFactory(adaptorFactory),
+        mResourceInstanceIdentifier(resourceIdentifier)
     {
     }
 
@@ -214,12 +217,133 @@ protected:
         return KAsync::null<void>();
     }
 
-    virtual KAsync::Job<qint64> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<Akonadi2::ApplicationDomain::Event::Ptr> > &resultProvider, qint64 oldRevision, qint64 newRevision) { return KAsync::null<qint64>(); };
+    static void scan(const QSharedPointer<Akonadi2::Storage> &storage, const QByteArray &key, std::function<bool(const QByteArray &key, const Akonadi2::Entity &entity)> callback)
+    {
+        storage->scan(key, [=](void *keyValue, int keySize, void *dataValue, int dataSize) -> bool {
+            //Skip internals
+            if (Akonadi2::Storage::isInternalKey(keyValue, keySize)) {
+                return true;
+            }
+
+            //Extract buffers
+            Akonadi2::EntityBuffer buffer(dataValue, dataSize);
+
+            //FIXME implement buffer.isValid()
+            // const auto resourceBuffer = Akonadi2::EntityBuffer::readBuffer<DummyEvent>(buffer.entity().resource());
+            // const auto localBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::ApplicationDomain::Buffer::Event>(buffer.entity().local());
+            // const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(buffer.entity().metadata());
+
+            // if ((!resourceBuffer && !localBuffer) || !metadataBuffer) {
+            //     qWarning() << "invalid buffer " << QByteArray::fromRawData(static_cast<char*>(keyValue), keySize);
+            //     return true;
+            // }
+            return callback(QByteArray::fromRawData(static_cast<char*>(keyValue), keySize), buffer.entity());
+        },
+        [](const Akonadi2::Storage::Error &error) {
+            qWarning() << "Error during query: " << error.message;
+        });
+    }
+
+    static void readValue(const QSharedPointer<Akonadi2::Storage> &storage, const QByteArray &key, const std::function<void(const typename DomainType::Ptr &)> &resultCallback, const QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > &adaptorFactory)
+    {
+        scan(storage, key, [=](const QByteArray &key, const Akonadi2::Entity &entity) {
+            const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(entity.metadata());
+            qint64 revision = metadataBuffer ? metadataBuffer->revision() : -1;
+            //This only works for a 1:1 mapping of resource to domain types.
+            //Not i.e. for tags that are stored as flags in each entity of an imap store.
+            //additional properties that don't have a 1:1 mapping (such as separately stored tags),
+            //could be added to the adaptor
+            auto domainObject = QSharedPointer<DomainType>::create("org.kde.dummy.instance1", key, revision, adaptorFactory->createAdaptor(entity));
+            resultCallback(domainObject);
+            return true;
+        });
+    }
+
+    static ResultSet fullScan(const QSharedPointer<Akonadi2::Storage> &storage)
+    {
+        //TODO use a result set with an iterator, to read values on demand
+        QVector<QByteArray> keys;
+        scan(storage, QByteArray(), [=, &keys](const QByteArray &key, const Akonadi2::Entity &) {
+            keys << key;
+            return true;
+        });
+        return ResultSet(keys);
+    }
+
+    static ResultSet filteredSet(const ResultSet &resultSet, const std::function<bool(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)> &filter, const QSharedPointer<Akonadi2::Storage> &storage, const QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > &adaptorFactory)
+    {
+        auto resultSetPtr = QSharedPointer<ResultSet>::create(resultSet);
+
+        //Read through the source values and return whatever matches the filter
+        std::function<bool(std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &)>)> generator = [resultSetPtr, storage, adaptorFactory, filter](std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &)> callback) -> bool {
+            while (resultSetPtr->next()) {
+                readValue(storage, resultSetPtr->id(), [filter, callback](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject) {
+                    if (filter(domainObject)) {
+                        callback(domainObject);
+                    }
+                }, adaptorFactory);
+            }
+            return false;
+        };
+        return ResultSet(generator);
+    }
 
+    static ResultSet getResultSet(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::Storage> &storage, const QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > &adaptorFactory, const QByteArray &resourceInstanceIdentifier)
+    {
+        QSet<QByteArray> appliedFilters;
+        ResultSet resultSet = Akonadi2::ApplicationDomain::TypeImplementation<DomainType>::queryIndexes(query, resourceInstanceIdentifier, appliedFilters);
+        const auto remainingFilters = query.propertyFilter.keys().toSet() - appliedFilters;
+
+        //We do a full scan if there were no indexes available to create the initial set.
+        if (appliedFilters.isEmpty()) {
+            resultSet = fullScan(storage);
+        }
+
+        auto filter = [remainingFilters, query](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject) -> bool {
+            for (const auto &filterProperty : remainingFilters) {
+                //TODO implement other comparison operators than equality
+                if (domainObject->getProperty(filterProperty) != query.propertyFilter.value(filterProperty)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+
+        return filteredSet(resultSet, filter, storage, adaptorFactory);
+    }
+
+    virtual KAsync::Job<qint64> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > &resultProvider, qint64 oldRevision, qint64 newRevision)
+    {
+        return KAsync::start<qint64>([=]() -> qint64 {
+            auto storage = QSharedPointer<Akonadi2::Storage>::create(Akonadi2::Store::storageLocation(), mResourceInstanceIdentifier);
+            storage->setDefaultErrorHandler([](const Akonadi2::Storage::Error &error) {
+                Warning() << "Error during query: " << error.store << error.message;
+            });
+
+            storage->startTransaction(Akonadi2::Storage::ReadOnly);
+            //TODO start transaction on indexes as well
+            const qint64 revision = storage->maxRevision();
+
+            auto resultSet = getResultSet(query, storage, mDomainTypeAdaptorFactory, mResourceInstanceIdentifier);
+
+            // TODO only emit changes and don't replace everything
+            resultProvider->clear();
+            auto resultCallback = std::bind(&Akonadi2::ResultProvider<typename DomainType::Ptr>::add, resultProvider, std::placeholders::_1);
+            while(resultSet.next([resultCallback](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &value) -> bool {
+                resultCallback(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(value));
+                return true;
+            })){};
+            storage->abortTransaction();
+            return revision;
+        });
+    }
+
+private:
 protected:
     //TODO use one resource access instance per application => make static
     QSharedPointer<Akonadi2::ResourceAccess> mResourceAccess;
     QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > mDomainTypeAdaptorFactory;
+    QByteArray mResourceInstanceIdentifier;
 };
 
 }
diff --git a/examples/dummyresource/facade.cpp b/examples/dummyresource/facade.cpp
index 002b836..d6e9286 100644
--- a/examples/dummyresource/facade.cpp
+++ b/examples/dummyresource/facade.cpp
@@ -19,25 +19,7 @@
 
 #include "facade.h"
 
-#include <QDebug>
-#include <functional>
-
-#include "common/resourceaccess.h"
-#include "common/commands.h"
-#include "common/resultset.h"
-#include "common/domain/event.h"
-#include "dummycalendar_generated.h"
-#include "event_generated.h"
-#include "entity_generated.h"
-#include "metadata_generated.h"
 #include "domainadaptor.h"
-#include <common/entitybuffer.h>
-#include <common/index.h>
-#include <common/log.h>
-
-using namespace DummyCalendar;
-using namespace flatbuffers;
-
 
 DummyResourceFacade::DummyResourceFacade()
     : Akonadi2::GenericFacade<Akonadi2::ApplicationDomain::Event>("org.kde.dummy.instance1", QSharedPointer<DummyEventAdaptorFactory>::create())
@@ -48,113 +30,3 @@ DummyResourceFacade::~DummyResourceFacade()
 {
 }
 
-static void scan(const QSharedPointer<Akonadi2::Storage> &storage, const QByteArray &key, std::function<bool(const QByteArray &key, const Akonadi2::Entity &entity, DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local, Akonadi2::Metadata const *metadata)> callback)
-{
-    storage->scan(key, [=](void *keyValue, int keySize, void *dataValue, int dataSize) -> bool {
-        //Skip internals
-        if (Akonadi2::Storage::isInternalKey(keyValue, keySize)) {
-            return true;
-        }
-
-        //Extract buffers
-        Akonadi2::EntityBuffer buffer(dataValue, dataSize);
-
-        const auto resourceBuffer = Akonadi2::EntityBuffer::readBuffer<DummyEvent>(buffer.entity().resource());
-        const auto localBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::ApplicationDomain::Buffer::Event>(buffer.entity().local());
-        const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(buffer.entity().metadata());
-
-        if ((!resourceBuffer && !localBuffer) || !metadataBuffer) {
-            qWarning() << "invalid buffer " << QByteArray::fromRawData(static_cast<char*>(keyValue), keySize);
-            return true;
-        }
-        return callback(QByteArray::fromRawData(static_cast<char*>(keyValue), keySize), buffer.entity(), resourceBuffer, localBuffer, metadataBuffer);
-    },
-    [](const Akonadi2::Storage::Error &error) {
-        qWarning() << "Error during query: " << error.message;
-    });
-}
-
-static void readValue(const QSharedPointer<Akonadi2::Storage> &storage, const QByteArray &key, const std::function<void(const Akonadi2::ApplicationDomain::Event::Ptr &)> &resultCallback, const QSharedPointer<DomainTypeAdaptorFactoryInterface<Akonadi2::ApplicationDomain::Event> > &adaptorFactory)
-{
-    scan(storage, key, [=](const QByteArray &key, const Akonadi2::Entity &entity, DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local, Akonadi2::Metadata const *metadataBuffer) {
-        qint64 revision = metadataBuffer ? metadataBuffer->revision() : -1;
-        //This only works for a 1:1 mapping of resource to domain types.
-        //Not i.e. for tags that are stored as flags in each entity of an imap store.
-        //additional properties that don't have a 1:1 mapping (such as separately stored tags),
-        //could be added to the adaptor
-        auto event = QSharedPointer<Akonadi2::ApplicationDomain::Event>::create("org.kde.dummy.instance1", key, revision, adaptorFactory->createAdaptor(entity));
-        resultCallback(event);
-        return true;
-    });
-}
-
-static ResultSet getResultSet(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::Storage> &storage, const QSharedPointer<DomainTypeAdaptorFactoryInterface<Akonadi2::ApplicationDomain::Event> > &adaptorFactory)
-{
-    QSet<QByteArray> appliedFilters;
-    ResultSet resultSet = Akonadi2::ApplicationDomain::TypeImplementation<Akonadi2::ApplicationDomain::Event>::queryIndexes(query, "org.kde.dummy.instance1", appliedFilters);
-    const auto remainingFilters = query.propertyFilter.keys().toSet() - appliedFilters;
-
-    //We do a full scan if there were no indexes available to create the initial set.
-    //TODO use a result set with an iterator, to read values on demand
-    if (appliedFilters.isEmpty()) {
-        QVector<QByteArray> keys;
-        scan(storage, QByteArray(), [=, &keys](const QByteArray &key, const Akonadi2::Entity &entity, DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local, Akonadi2::Metadata const *metadataBuffer) {
-            keys << key;
-            return true;
-        });
-        resultSet = ResultSet(keys);
-    }
-
-    auto filter = [remainingFilters, query](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &event) -> bool {
-        for (const auto &filterProperty : remainingFilters) {
-            //TODO implement other comparison operators than equality
-            if (event->getProperty(filterProperty) != query.propertyFilter.value(filterProperty)) {
-                return false;
-            }
-        }
-        return true;
-    };
-
-    auto resultSetPtr = QSharedPointer<ResultSet>::create(resultSet);
-
-    //Read through the source values and return whatever matches the filter
-    std::function<bool(std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &)>)> generator = [resultSetPtr, storage, adaptorFactory, filter](std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &)> callback) -> bool {
-        while (resultSetPtr->next()) {
-            Akonadi2::ApplicationDomain::Event::Ptr event;
-            readValue(storage, resultSetPtr->id(), [filter, callback](const Akonadi2::ApplicationDomain::Event::Ptr &event) {
-                if (filter(event)) {
-                    callback(event);
-                }
-            }, adaptorFactory);
-        }
-        return false;
-    };
-    return ResultSet(generator);
-}
-
-//TODO generalize
-KAsync::Job<qint64> DummyResourceFacade::load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<Akonadi2::ApplicationDomain::Event::Ptr> > &resultProvider, qint64 oldRevision, qint64 newRevision)
-{
-    return KAsync::start<qint64>([=]() {
-        auto storage = QSharedPointer<Akonadi2::Storage>::create(Akonadi2::Store::storageLocation(), "org.kde.dummy.instance1");
-        storage->setDefaultErrorHandler([](const Akonadi2::Storage::Error &error) {
-            Warning() << "Error during query: " << error.store << error.message;
-        });
-
-        storage->startTransaction(Akonadi2::Storage::ReadOnly);
-        //TODO start transaction on indexes as well
-        const qint64 revision = storage->maxRevision();
-
-        auto resultSet = getResultSet(query, storage, mDomainTypeAdaptorFactory);
-
-        // TODO only emit changes and don't replace everything
-        resultProvider->clear();
-        auto resultCallback = std::bind(&Akonadi2::ResultProvider<Akonadi2::ApplicationDomain::Event::Ptr>::add, resultProvider, std::placeholders::_1);
-        while(resultSet.next([resultCallback](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &value) -> bool {
-            resultCallback(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<Akonadi2::ApplicationDomain::Event>(value));
-        })){};
-        storage->abortTransaction();
-        return revision;
-    });
-}
-
diff --git a/examples/dummyresource/facade.h b/examples/dummyresource/facade.h
index 7c894f1..441dc38 100644
--- a/examples/dummyresource/facade.h
+++ b/examples/dummyresource/facade.h
@@ -20,22 +20,11 @@
 #pragma once
 
 #include "common/facade.h"
-
-#include "common/clientapi.h"
-#include "common/storage.h"
-#include "resourcefactory.h"
-#include "entity_generated.h"
-#include "event_generated.h"
-#include "dummycalendar_generated.h"
-#include "common/domainadaptor.h"
+#include "common/domain/event.h"
 
 class DummyResourceFacade : public Akonadi2::GenericFacade<Akonadi2::ApplicationDomain::Event>
 {
 public:
     DummyResourceFacade();
     virtual ~DummyResourceFacade();
-    KAsync::Job<qint64> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<Akonadi2::ApplicationDomain::Event::Ptr> > &resultProvider, qint64 oldRevision, qint64 newRevision) Q_DECL_OVERRIDE;
-
-private:
-    void readValue(const QSharedPointer<Akonadi2::Storage> &storage, const QByteArray &key, const std::function<void(const Akonadi2::ApplicationDomain::Event::Ptr &)> &resultCallback);
 };