5 files changed, 78 insertions, 223 deletions

diff --git a/dummyresource/domainadaptor.cpp b/dummyresource/domainadaptor.cpp
index 2182f9a..fa00bbc 100644
--- a/dummyresource/domainadaptor.cpp
+++ b/dummyresource/domainadaptor.cpp
@@ -9,142 +9,55 @@
 #include "entity_generated.h"
 #include "metadata_generated.h"
 #include "domainadaptor.h"
+#include "log.h"
 #include <common/entitybuffer.h>
 
 using namespace DummyCalendar;
 using namespace flatbuffers;
 
-using namespace DummyCalendar;
-using namespace flatbuffers;
-
-//This will become a generic implementation that simply takes the resource buffer and local buffer pointer
-class DummyEventAdaptor : public Akonadi2::Domain::BufferAdaptor
-{
-public:
-    DummyEventAdaptor()
-        : BufferAdaptor()
-    {
-
-    }
-
-    void setProperty(const QString &key, const QVariant &value)
-    {
-        if (mResourceMapper && mResourceMapper->mWriteAccessors.contains(key)) {
-            // mResourceMapper->setProperty(key, value, mResourceBuffer);
-        } else {
-            // mLocalMapper.;
-        }
-    }
 
-    virtual QVariant getProperty(const QString &key) const
-    {
-        if (mResourceBuffer && mResourceMapper->mReadAccessors.contains(key)) {
-            return mResourceMapper->getProperty(key, mResourceBuffer);
-        } else if (mLocalBuffer && mLocalMapper->mReadAccessors.contains(key)) {
-            return mLocalMapper->getProperty(key, mLocalBuffer);
-        }
-        qWarning() << "no mapping available for key " << key;
-        return QVariant();
-    }
-
-    virtual QStringList availableProperties() const
-    {
-        QStringList props;
-        props << mResourceMapper->mReadAccessors.keys();
-        props << mLocalMapper->mReadAccessors.keys();
-        return props;
-    }
-
-    Akonadi2::Domain::Buffer::Event const *mLocalBuffer;
-    DummyEvent const *mResourceBuffer;
-
-    QSharedPointer<PropertyMapper<Akonadi2::Domain::Buffer::Event> > mLocalMapper;
-    QSharedPointer<PropertyMapper<DummyEvent> > mResourceMapper;
-};
 
 
 DummyEventAdaptorFactory::DummyEventAdaptorFactory()
     : DomainTypeAdaptorFactory()
 {
-    mResourceMapper = QSharedPointer<PropertyMapper<DummyEvent> >::create();
-    mResourceMapper->mReadAccessors.insert("summary", [](DummyEvent const *buffer) -> QVariant {
-        if (buffer->summary()) {
-            return QString::fromStdString(buffer->summary()->c_str());
-        }
-        return QVariant();
-    });
-    mLocalMapper = QSharedPointer<PropertyMapper<Akonadi2::Domain::Buffer::Event> >::create();
-    mLocalMapper->mReadAccessors.insert("summary", [](Akonadi2::Domain::Buffer::Event const *buffer) -> QVariant {
+    //TODO turn this into initializeReadPropertyMapper as well?
+    mResourceMapper->addMapping("summary", [](DummyEvent const *buffer) -> QVariant {
         if (buffer->summary()) {
             return QString::fromStdString(buffer->summary()->c_str());
         }
         return QVariant();
     });
-    mLocalMapper->mReadAccessors.insert("uid", [](Akonadi2::Domain::Buffer::Event const *buffer) -> QVariant {
-        if (buffer->uid()) {
-            return QString::fromStdString(buffer->uid()->c_str());
-        }
-        return QVariant();
-    });
 
+    mResourceWriteMapper->addMapping("summary", [](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(DummyEventBuilder &)> {
+        auto offset = extractProperty<QString>(value, fbb);
+        return [offset](DummyEventBuilder &builder) { builder.add_summary(offset); };
+    });
 }
 
-//TODO pass EntityBuffer instead?
-QSharedPointer<Akonadi2::Domain::BufferAdaptor> DummyEventAdaptorFactory::createAdaptor(const Akonadi2::Entity &entity)
+
+void DummyEventAdaptorFactory::createBuffer(const Akonadi2::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb)
 {
-    DummyEvent const *resourceBuffer = 0;
-    if (auto resourceData = entity.resource()) {
-        flatbuffers::Verifier verifyer(resourceData->Data(), resourceData->size());
-        if (VerifyDummyEventBuffer(verifyer)) {
-            resourceBuffer = GetDummyEvent(resourceData->Data());
+    flatbuffers::FlatBufferBuilder localFbb;
+    if (mLocalWriteMapper) {
+        auto pos = createBufferPart<Akonadi2::ApplicationDomain::Buffer::EventBuilder, Akonadi2::ApplicationDomain::Buffer::Event>(event, localFbb, *mLocalWriteMapper);
+        Akonadi2::ApplicationDomain::Buffer::FinishEventBuffer(localFbb, pos);
+        flatbuffers::Verifier verifier(localFbb.GetBufferPointer(), localFbb.GetSize());
+        if (!verifier.VerifyBuffer<Akonadi2::ApplicationDomain::Buffer::Event>()) {
+            Warning() << "Created invalid local buffer";
         }
     }
 
-    // Akonadi2::Metadata const *metadataBuffer = 0;
-    // if (auto metadataData = entity.metadata()) {
-    //     flatbuffers::Verifier verifyer(metadataData->Data(), metadataData->size());
-    //     if (Akonadi2::VerifyMetadataBuffer(verifyer)) {
-    //         metadataBuffer = Akonadi2::GetMetadata(metadataData->Data());
-    //     }
-    // }
-
-    Akonadi2::Domain::Buffer::Event const *localBuffer = 0;
-    if (auto localData = entity.local()) {
-        flatbuffers::Verifier verifyer(localData->Data(), localData->size());
-        if (Akonadi2::Domain::Buffer::VerifyEventBuffer(verifyer)) {
-            localBuffer = Akonadi2::Domain::Buffer::GetEvent(localData->Data());
+    flatbuffers::FlatBufferBuilder resFbb;
+    if (mResourceWriteMapper) {
+        auto pos = createBufferPart<DummyEventBuilder, DummyEvent>(event, resFbb, *mResourceWriteMapper);
+        DummyCalendar::FinishDummyEventBuffer(resFbb, pos);
+        flatbuffers::Verifier verifier(resFbb.GetBufferPointer(), resFbb.GetSize());
+        if (!verifier.VerifyBuffer<DummyEvent>()) {
+            Warning() << "Created invalid resource buffer";
         }
     }
 
-    auto adaptor = QSharedPointer<DummyEventAdaptor>::create();
-    adaptor->mLocalBuffer = localBuffer;
-    adaptor->mLocalMapper = mLocalMapper;
-    adaptor->mResourceBuffer = resourceBuffer;
-    adaptor->mResourceMapper = mResourceMapper;
-    return adaptor;
-}
-
-void DummyEventAdaptorFactory::createBuffer(const Akonadi2::Domain::Event &event, flatbuffers::FlatBufferBuilder &fbb)
-{
-    flatbuffers::FlatBufferBuilder eventFbb;
-    eventFbb.Clear();
-    {
-        auto summary = eventFbb.CreateString(event.getProperty("summary").toString().toStdString());
-        DummyCalendar::DummyEventBuilder eventBuilder(eventFbb);
-        eventBuilder.add_summary(summary);
-        auto eventLocation = eventBuilder.Finish();
-        DummyCalendar::FinishDummyEventBuffer(eventFbb, eventLocation);
-    }
-
-    flatbuffers::FlatBufferBuilder localFbb;
-    {
-        auto uid = localFbb.CreateString(event.getProperty("uid").toString().toStdString());
-        auto localBuilder = Akonadi2::Domain::Buffer::EventBuilder(localFbb);
-        localBuilder.add_uid(uid);
-        auto location = localBuilder.Finish();
-        Akonadi2::Domain::Buffer::FinishEventBuffer(localFbb, location);
-    }
-
-    Akonadi2::EntityBuffer::assembleEntityBuffer(fbb, 0, 0, eventFbb.GetBufferPointer(), eventFbb.GetSize(), localFbb.GetBufferPointer(), localFbb.GetSize());
+    Akonadi2::EntityBuffer::assembleEntityBuffer(fbb, 0, 0, resFbb.GetBufferPointer(), resFbb.GetSize(), localFbb.GetBufferPointer(), localFbb.GetSize());
 }
 
diff --git a/dummyresource/domainadaptor.h b/dummyresource/domainadaptor.h
index 9474176..9d351e7 100644
--- a/dummyresource/domainadaptor.h
+++ b/dummyresource/domainadaptor.h
@@ -1,4 +1,3 @@
-
 #pragma once
 
 #include "common/domainadaptor.h"
@@ -6,11 +5,10 @@
 #include "dummycalendar_generated.h"
 #include "entity_generated.h"
 
-class DummyEventAdaptorFactory : public DomainTypeAdaptorFactory<Akonadi2::Domain::Event, Akonadi2::Domain::Buffer::Event, DummyCalendar::DummyEvent>
+class DummyEventAdaptorFactory : public DomainTypeAdaptorFactory<Akonadi2::ApplicationDomain::Event, Akonadi2::ApplicationDomain::Buffer::Event, DummyCalendar::DummyEvent, Akonadi2::ApplicationDomain::Buffer::EventBuilder, DummyCalendar::DummyEventBuilder>
 {
 public:
     DummyEventAdaptorFactory();
     virtual ~DummyEventAdaptorFactory() {};
-    virtual QSharedPointer<Akonadi2::Domain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity);
-    virtual void createBuffer(const Akonadi2::Domain::Event &event, flatbuffers::FlatBufferBuilder &fbb);
+    virtual void createBuffer(const Akonadi2::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb);
 };
diff --git a/dummyresource/facade.cpp b/dummyresource/facade.cpp
index 949b4c4..1477fcf 100644
--- a/dummyresource/facade.cpp
+++ b/dummyresource/facade.cpp
@@ -28,7 +28,6 @@
 #include "event_generated.h"
 #include "entity_generated.h"
 #include "metadata_generated.h"
-#include "createentity_generated.h"
 #include "domainadaptor.h"
 #include <common/entitybuffer.h>
 #include <common/index.h>
@@ -37,9 +36,9 @@
 using namespace DummyCalendar;
 using namespace flatbuffers;
 
+
 DummyResourceFacade::DummyResourceFacade()
-    : Akonadi2::StoreFacade<Akonadi2::Domain::Event>(),
-    mResourceAccess(new Akonadi2::ResourceAccess("org.kde.dummy")),
+    : Akonadi2::GenericFacade<Akonadi2::ApplicationDomain::Event>("org.kde.dummy"),
     mFactory(new DummyEventAdaptorFactory)
 {
 }
@@ -48,38 +47,30 @@ DummyResourceFacade::~DummyResourceFacade()
 {
 }
 
-Async::Job<void> DummyResourceFacade::create(const Akonadi2::Domain::Event &domainObject)
+Async::Job<void> DummyResourceFacade::create(const Akonadi2::ApplicationDomain::Event &domainObject)
 {
     flatbuffers::FlatBufferBuilder entityFbb;
     mFactory->createBuffer(domainObject, entityFbb);
-
-    flatbuffers::FlatBufferBuilder fbb;
-    //This is the resource buffer type and not the domain type
-    auto type = fbb.CreateString("event");
-    auto delta = fbb.CreateVector<uint8_t>(entityFbb.GetBufferPointer(), entityFbb.GetSize());
-    auto location = Akonadi2::Commands::CreateCreateEntity(fbb, type, delta);
-    Akonadi2::Commands::FinishCreateEntityBuffer(fbb, location);
-    mResourceAccess->open();
-    return mResourceAccess->sendCommand(Akonadi2::Commands::CreateEntityCommand, fbb);
+    return sendCreateCommand("event", QByteArray::fromRawData(reinterpret_cast<const char*>(entityFbb.GetBufferPointer()), entityFbb.GetSize()));
 }
 
-Async::Job<void> DummyResourceFacade::modify(const Akonadi2::Domain::Event &domainObject)
+Async::Job<void> DummyResourceFacade::modify(const Akonadi2::ApplicationDomain::Event &domainObject)
 {
     //Create message buffer and send to resource
     return Async::null<void>();
 }
 
-Async::Job<void> DummyResourceFacade::remove(const Akonadi2::Domain::Event &domainObject)
+Async::Job<void> DummyResourceFacade::remove(const Akonadi2::ApplicationDomain::Event &domainObject)
 {
     //Create message buffer and send to resource
     return Async::null<void>();
 }
 
-static std::function<bool(const std::string &key, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local)> prepareQuery(const Akonadi2::Query &query)
+static std::function<bool(const std::string &key, DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local)> prepareQuery(const Akonadi2::Query &query)
 {
     //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, Akonadi2::Domain::Buffer::Event const *local)> preparedQuery;
+    std::function<bool(const std::string &key, DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local)> preparedQuery;
     if (!query.ids.isEmpty()) {
         //Match by id
         //TODO: for id's a direct lookup would be way faster
@@ -90,7 +81,7 @@ static std::function<bool(const std::string &key, DummyEvent const *buffer, Akon
         for (const auto &id : query.ids) {
             ids << id.toStdString();
         }
-        preparedQuery = [ids](const std::string &key, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local) {
+        preparedQuery = [ids](const std::string &key, DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local) {
             if (ids.contains(key)) {
                 return true;
             }
@@ -99,7 +90,7 @@ static std::function<bool(const std::string &key, DummyEvent const *buffer, Akon
     } else if (!query.propertyFilter.isEmpty()) {
         if (query.propertyFilter.contains("uid")) {
             const QByteArray uid = query.propertyFilter.value("uid").toByteArray();
-            preparedQuery = [uid](const std::string &key, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local) {
+            preparedQuery = [uid](const std::string &key, DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local) {
                 if (local && local->uid() && (QByteArray::fromRawData(local->uid()->c_str(), local->uid()->size()) == uid)) {
                     return true;
                 }
@@ -108,32 +99,14 @@ static std::function<bool(const std::string &key, DummyEvent const *buffer, Akon
         }
     } else {
         //Match everything
-        preparedQuery = [](const std::string &key, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local) {
+        preparedQuery = [](const std::string &key, DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local) {
             return true;
         };
     }
     return preparedQuery;
 }
 
-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 || processAll) {
-        return Async::start<void>([=](Async::Future<void> &future) {
-            mResourceAccess->open();
-            mResourceAccess->synchronizeResource(sync, processAll).then<void>([&future](Async::Future<void> &f) {
-                future.setFinished();
-                f.setFinished();
-            }).exec();
-        });
-    }
-    return Async::null<void>();
-}
-
-void DummyResourceFacade::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, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local)> preparedQuery)
+void DummyResourceFacade::readValue(QSharedPointer<Akonadi2::Storage> storage, const QByteArray &key, const std::function<void(const Akonadi2::ApplicationDomain::Event::Ptr &)> &resultCallback, std::function<bool(const std::string &key, DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local)> preparedQuery)
 {
     storage->scan(key, [=](void *keyValue, int keySize, void *dataValue, int dataSize) -> bool {
 
@@ -145,31 +118,11 @@ void DummyResourceFacade::readValue(QSharedPointer<Akonadi2::Storage> storage, c
         //Extract buffers
         Akonadi2::EntityBuffer buffer(dataValue, dataSize);
 
-        DummyEvent const *resourceBuffer = 0;
-        if (auto resourceData = buffer.entity().resource()) {
-            flatbuffers::Verifier verifyer(resourceData->Data(), resourceData->size());
-            if (VerifyDummyEventBuffer(verifyer)) {
-                resourceBuffer = GetDummyEvent(resourceData->Data());
-            }
-        }
-
-        Akonadi2::Domain::Buffer::Event const *localBuffer = 0;
-        if (auto localData = buffer.entity().local()) {
-            flatbuffers::Verifier verifyer(localData->Data(), localData->size());
-            if (Akonadi2::Domain::Buffer::VerifyEventBuffer(verifyer)) {
-                localBuffer = Akonadi2::Domain::Buffer::GetEvent(localData->Data());
-            }
-        }
-
-        Akonadi2::Metadata const *metadataBuffer = 0;
-        if (auto metadataData = buffer.entity().metadata()) {
-            flatbuffers::Verifier verifyer(metadataData->Data(), metadataData->size());
-            if (Akonadi2::VerifyMetadataBuffer(verifyer)) {
-                metadataBuffer = Akonadi2::GetMetadata(metadataData->Data());
-            }
-        }
+        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 || !metadataBuffer) {
+        if ((!resourceBuffer && !localBuffer) || !metadataBuffer) {
             qWarning() << "invalid buffer " << QByteArray::fromRawData(static_cast<char*>(keyValue), keySize);
             return true;
         }
@@ -182,8 +135,9 @@ void DummyResourceFacade::readValue(QSharedPointer<Akonadi2::Storage> storage, c
             //Not i.e. for tags that are stored as flags in each entity of an imap store.
             auto adaptor = mFactory->createAdaptor(buffer.entity());
             //TODO only copy requested properties
-            auto memoryAdaptor = QSharedPointer<Akonadi2::Domain::MemoryBufferAdaptor>::create(*adaptor);
-            auto event = QSharedPointer<Akonadi2::Domain::Event>::create("org.kde.dummy", QString::fromUtf8(static_cast<char*>(keyValue), keySize), revision, memoryAdaptor);
+            auto memoryAdaptor = QSharedPointer<Akonadi2::ApplicationDomain::MemoryBufferAdaptor>::create(*adaptor);
+            // here we could copy additional properties that don't have a 1:1 mapping, such as separately stored tags.
+            auto event = QSharedPointer<Akonadi2::ApplicationDomain::Event>::create("org.kde.dummy", QByteArray::fromRawData(static_cast<char*>(keyValue), keySize), revision, memoryAdaptor);
             resultCallback(event);
         }
         return true;
@@ -193,7 +147,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)
+Async::Job<void> DummyResourceFacade::load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::ApplicationDomain::Event::Ptr &)> &resultCallback)
 {
     return synchronizeResource(query.syncOnDemand, query.processAll).then<void>([=](Async::Future<void> &future) {
         //Now that the sync is complete we can execute the query
@@ -201,6 +155,9 @@ Async::Job<void> DummyResourceFacade::load(const Akonadi2::Query &query, const s
 
         auto storage = QSharedPointer<Akonadi2::Storage>::create(Akonadi2::Store::storageLocation(), "org.kde.dummy");
 
+        //TODO use transaction over full query and record store revision. We'll need it to update the query.
+
+        //Index lookups
         QVector<QByteArray> keys;
         if (query.propertyFilter.contains("uid")) {
             static Index uidIndex(Akonadi2::Store::storageLocation(), "org.kde.dummy.index.uid", Akonadi2::Storage::ReadOnly);
diff --git a/dummyresource/facade.h b/dummyresource/facade.h
index 1f69161..37ed81d 100644
--- a/dummyresource/facade.h
+++ b/dummyresource/facade.h
@@ -19,6 +19,8 @@
 
 #pragma once
 
+#include "common/facade.h"
+
 #include "common/clientapi.h"
 #include "common/storage.h"
 #include "resourcefactory.h"
@@ -27,24 +29,17 @@
 #include "dummycalendar_generated.h"
 #include "common/domainadaptor.h"
 
-namespace Akonadi2 {
-    class ResourceAccess;
-}
-
-
-class DummyResourceFacade : public Akonadi2::StoreFacade<Akonadi2::Domain::Event>
+class DummyResourceFacade : public Akonadi2::GenericFacade<Akonadi2::ApplicationDomain::Event>
 {
 public:
     DummyResourceFacade();
     virtual ~DummyResourceFacade();
-    virtual Async::Job<void> create(const Akonadi2::Domain::Event &domainObject);
-    virtual Async::Job<void> modify(const Akonadi2::Domain::Event &domainObject);
-    virtual Async::Job<void> remove(const Akonadi2::Domain::Event &domainObject);
-    virtual Async::Job<void> load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback);
+    virtual Async::Job<void> create(const Akonadi2::ApplicationDomain::Event &domainObject);
+    virtual Async::Job<void> modify(const Akonadi2::ApplicationDomain::Event &domainObject);
+    virtual Async::Job<void> remove(const Akonadi2::ApplicationDomain::Event &domainObject);
+    virtual Async::Job<void> load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::ApplicationDomain::Event::Ptr &)> &resultCallback);
 
 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, bool processAll);
-    QSharedPointer<Akonadi2::ResourceAccess> mResourceAccess;
-    QSharedPointer<DomainTypeAdaptorFactory<Akonadi2::Domain::Event, Akonadi2::Domain::Buffer::Event, DummyCalendar::DummyEvent> > mFactory;
+    void readValue(QSharedPointer<Akonadi2::Storage> storage, const QByteArray &key, const std::function<void(const Akonadi2::ApplicationDomain::Event::Ptr &)> &resultCallback, std::function<bool(const std::string &key, DummyCalendar::DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local)>);
+    QSharedPointer<DomainTypeAdaptorFactory<Akonadi2::ApplicationDomain::Event, Akonadi2::ApplicationDomain::Buffer::Event, DummyCalendar::DummyEvent, Akonadi2::ApplicationDomain::Buffer::EventBuilder, DummyCalendar::DummyEventBuilder> > mFactory;
 };
diff --git a/dummyresource/resourcefactory.cpp b/dummyresource/resourcefactory.cpp
index dda34ef..8f0a2bd 100644
--- a/dummyresource/resourcefactory.cpp
+++ b/dummyresource/resourcefactory.cpp
@@ -191,7 +191,7 @@ private slots:
                             return;
                         }
                         auto queuedCommand = Akonadi2::GetQueuedCommand(ptr);
-                        qDebug() << "Dequeued: " << queuedCommand->commandId();
+                        Trace() << "Dequeued: " << queuedCommand->commandId();
                         //TODO JOBAPI: job lifetime management
                         //Right now we're just leaking jobs. In this case we'd like jobs that are heap allocated and delete
                         //themselves once done. In other cases we'd like jobs that only live as long as their handle though.
@@ -256,29 +256,18 @@ void DummyResource::configurePipeline(Akonadi2::Pipeline *pipeline)
     //Eventually the order should be self configuring, for now it's hardcoded.
     auto eventIndexer = new SimpleProcessor("summaryprocessor", [eventFactory](const Akonadi2::PipelineState &state, const Akonadi2::Entity &entity) {
         auto adaptor = eventFactory->createAdaptor(entity);
-        // qDebug() << "Summary preprocessor: " << adaptor->getProperty("summary").toString();
+        // Log() << "Summary preprocessor: " << adaptor->getProperty("summary").toString();
     });
 
     auto uidIndexer = new SimpleProcessor("uidIndexer", [eventFactory](const Akonadi2::PipelineState &state, const Akonadi2::Entity &entity) {
         static Index uidIndex(QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/akonadi2/storage", "org.kde.dummy.index.uid", Akonadi2::Storage::ReadWrite);
 
+        //TODO: Benchmark if this is performance wise acceptable, or if we have to access the buffer directly
         auto adaptor = eventFactory->createAdaptor(entity);
         const auto uid = adaptor->getProperty("uid");
         if (uid.isValid()) {
             uidIndex.add(uid.toByteArray(), state.key());
         }
-
-        //TODO would this be worthwhile for performance reasons?
-        // flatbuffers::Verifier verifyer(entity.local()->Data(), entity.local()->size());
-        // if (!Akonadi2::Domain::Buffer::VerifyEventBuffer(verifyer)) {
-        //     qWarning() << "invalid local buffer";
-        //     return;
-        // }
-        // auto localEvent = Akonadi2::Domain::Buffer::GetEvent(entity.local()->Data());
-        // if (localEvent && localEvent->uid()) {
-        //     qDebug() << "got uid: " << QByteArray::fromRawData(reinterpret_cast<const char *>(localEvent->uid()->Data()), localEvent->uid()->size());
-        //     uidIndex.add(QByteArray::fromRawData(reinterpret_cast<const char *>(localEvent->uid()->Data()), localEvent->uid()->size()), state.key());
-        // }
     });
 
     //event is the entitytype and not the domain type
@@ -289,7 +278,7 @@ void DummyResource::configurePipeline(Akonadi2::Pipeline *pipeline)
 
 void DummyResource::onProcessorError(int errorCode, const QString &errorMessage)
 {
-    qWarning() << "Received error from Processor: " << errorCode << errorMessage;
+    Warning() << "Received error from Processor: " << errorCode << errorMessage;
     mError = errorCode;
 }
 
@@ -325,11 +314,8 @@ void findByRemoteId(QSharedPointer<Akonadi2::Storage> storage, const QString &ri
 void DummyResource::enqueueCommand(MessageQueue &mq, int commandId, const QByteArray &data)
 {
     m_fbb.Clear();
-    auto commandData = m_fbb.CreateVector(reinterpret_cast<uint8_t const *>(data.data()), data.size());
-    auto builder = Akonadi2::QueuedCommandBuilder(m_fbb);
-    builder.add_commandId(commandId);
-    builder.add_command(commandData);
-    auto buffer = builder.Finish();
+    auto commandData = Akonadi2::EntityBuffer::appendAsVector(m_fbb, data.constData(), data.size());
+    auto buffer = Akonadi2::CreateQueuedCommand(m_fbb, commandId, commandData);
     Akonadi2::FinishQueuedCommandBuffer(m_fbb, buffer);
     mq.enqueue(m_fbb.GetBufferPointer(), m_fbb.GetSize());
 }
@@ -357,7 +343,7 @@ Async::Job<void> DummyResource::synchronizeWithSource(Akonadi2::Pipeline *pipeli
                 auto rid = m_fbb.CreateString(it.key().toStdString().c_str());
                 auto description = m_fbb.CreateString(it.key().toStdString().c_str());
                 static uint8_t rawData[100];
-                auto attachment = m_fbb.CreateVector(rawData, 100);
+                auto attachment = Akonadi2::EntityBuffer::appendAsVector(m_fbb, rawData, 100);
 
                 auto builder = DummyCalendar::DummyEventBuilder(m_fbb);
                 builder.add_summary(summary);
@@ -372,7 +358,7 @@ Async::Job<void> DummyResource::synchronizeWithSource(Akonadi2::Pipeline *pipeli
                 flatbuffers::FlatBufferBuilder fbb;
                 //This is the resource type and not the domain type
                 auto type = fbb.CreateString("event");
-                auto delta = fbb.CreateVector<uint8_t>(entityFbb.GetBufferPointer(), entityFbb.GetSize());
+                auto delta = Akonadi2::EntityBuffer::appendAsVector(fbb, entityFbb.GetBufferPointer(), entityFbb.GetSize());
                 auto location = Akonadi2::Commands::CreateCreateEntity(fbb, type, delta);
                 Akonadi2::Commands::FinishCreateEntityBuffer(fbb, location);
 
@@ -388,16 +374,22 @@ Async::Job<void> DummyResource::synchronizeWithSource(Akonadi2::Pipeline *pipeli
 
 Async::Job<void> DummyResource::processAllMessages()
 {
+    //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?
+    //TODO JOBAPI: A helper that waits for n events and then continues?
     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?
-        //TODO: also check user-queue?
         if (mSynchronizerQueue.isEmpty()) {
-            qDebug() << "synchronizer queue is empty";
             f.setFinished();
         } else {
             QObject::connect(&mSynchronizerQueue, &MessageQueue::drained, [&f]() {
-                qDebug() << "synchronizer queue drained";
+                f.setFinished();
+            });
+        }
+    }).then<void>([this](Async::Future<void> &f) {
+        if (mUserQueue.isEmpty()) {
+            f.setFinished();
+        } else {
+            QObject::connect(&mUserQueue, &MessageQueue::drained, [&f]() {
                 f.setFinished();
             });
         }
@@ -425,7 +417,7 @@ Akonadi2::Resource *DummyResourceFactory::createResource()
 
 void DummyResourceFactory::registerFacades(Akonadi2::FacadeFactory &factory)
 {
-    factory.registerFacade<Akonadi2::Domain::Event, DummyResourceFacade>(PLUGIN_NAME);
+    factory.registerFacade<Akonadi2::ApplicationDomain::Event, DummyResourceFacade>(PLUGIN_NAME);
 }
 
 #include "resourcefactory.moc"