1 files changed, 42 insertions, 10 deletions

diff --git a/dummyresource/facade.cpp b/dummyresource/facade.cpp
index bfe1de4..44056f8 100644
--- a/dummyresource/facade.cpp
+++ b/dummyresource/facade.cpp
@@ -10,8 +10,7 @@ using namespace flatbuffers;
 
 DummyResourceFacade::DummyResourceFacade()
     : Akonadi2::StoreFacade<Akonadi2::Domain::Event>(),
-    mResourceAccess(new ResourceAccess("dummyresource")),
-    mStorage(new Storage(Akonadi2::Store::storageLocation(), "dummyresource"))
+    mResourceAccess(/* new ResourceAccess("dummyresource") */)
 {
     // connect(mResourceAccess.data(), &ResourceAccess::ready, this, onReadyChanged);
 }
@@ -47,7 +46,10 @@ void DummyResourceFacade::remove(const Akonadi2::Domain::Event &domainObject)
 //=> perhaps do heap allocate and use smart pointer?
 class DummyEventAdaptor : public Akonadi2::Domain::Event {
 public:
-    DummyEventAdaptor(const QString &resource, const QString &identifier, qint64 revision):Akonadi2::Domain::Event(resource, identifier, revision){};
+    DummyEventAdaptor(const QString &resource, const QString &identifier, qint64 revision)
+        :Akonadi2::Domain::Event(resource, identifier, revision)
+    {
+    }
 
     //TODO
     // void setProperty(const QString &key, const QVariant &value)
@@ -75,15 +77,45 @@ public:
 void DummyResourceFacade::load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback)
 {
     qDebug() << "load called";
-    //TODO only read values matching the query
     auto storage = QSharedPointer<Storage>::create(Akonadi2::Store::storageLocation(), "dummyresource");
-    storage->read("", [resultCallback, storage](void *data, int size) -> bool {
+
+    //Compose some functions to make query matching fast.
+    //This way we can process the query once, and convert all values into something that can be compared quickly
+    std::function<bool(const std::string &key, DummyEvent const *buffer)> preparedQuery;
+    if (!query.ids.isEmpty()) {
+        //Match by id
+        //TODO: for id's a direct lookup would be way faster
+
+        //We convert the id's to std::string so we don't have to convert each key during the scan. (This runs only once, and the query will be run for every key)
+        //Probably a premature optimization, but perhaps a useful technique to be investigated.
+        QVector<std::string> ids;
+        for (const auto &id : query.ids) {
+            ids << id.toStdString();
+        }
+        preparedQuery = [ids](const std::string &key, DummyEvent const *buffer) {
+            if (ids.contains(key)) {
+                return true;
+            }
+            return false;
+        };
+    } else {
+        //Match everything
+        preparedQuery = [](const std::string &key, DummyEvent const *buffer) {
+            return true;
+        };
+    }
+
+    //Because we have no indexes yet, we always do a full scan
+    storage->scan("", [=](void *keyValue, int keySize, void *dataValue, int dataSize) -> bool {
         //TODO read second buffer as well
-        auto eventBuffer = GetDummyEvent(data);
-        auto event = QSharedPointer<DummyEventAdaptor>::create("dummyresource", "key", 0);
-        event->buffer = eventBuffer;
-        event->storage = storage;
-        resultCallback(event);
+        auto eventBuffer = GetDummyEvent(dataValue);
+        if (preparedQuery && preparedQuery(std::string(static_cast<char*>(keyValue), keySize), eventBuffer)) {
+            //TODO read the revision from the generic portion of the buffer
+            auto event = QSharedPointer<DummyEventAdaptor>::create("dummyresource", QString::fromUtf8(static_cast<char*>(keyValue), keySize), 0);
+            event->buffer = eventBuffer;
+            event->storage = storage;
+            resultCallback(event);
+        }
         return true;
     });
 }