29 files changed, 669 insertions, 455 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 97c4466..bc16184 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -36,12 +36,14 @@ function(generate_flatbuffers)
 endfunction(generate_flatbuffers)
 set(CMAKE_AUTOMOC ON)
-add_definitions("-Wall -std=c++0x")
+add_definitions("-Wall -std=c++0x -g")
 include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR} ${FLATBUFFERS_INCLUDE_DIR} ${CMAKE_BINARY_DIR}/common)
 include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/common)
 configure_file(hawd.conf hawd.conf)
+enable_testing()
 set(AKONADI2_RESOURCE_PLUGINS_PATH ${QT_PLUGIN_INSTALL_DIR}/akonadi2/resources)
 # common, eventually a lib but right now just the command buffers
diff --git a/client/main.cpp b/client/main.cpp
index 61c1c1a..b4cb081 100644
--- a/client/main.cpp
+++ b/client/main.cpp
@@ -41,7 +41,7 @@ int main(int argc, char *argv[])
    }
    for (const QString &resource: resources) {
-        Akonadi2::ResourceAccess *resAccess = new Akonadi2::ResourceAccess(resource);
+        Akonadi2::ResourceAccess *resAccess = new Akonadi2::ResourceAccess(resource.toLatin1());
        QObject::connect(&app, &QCoreApplication::aboutToQuit,
                        resAccess, &Akonadi2::ResourceAccess::close);
        resAccess->sendCommand(Akonadi2::Commands::SynchronizeCommand);
diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 650691c..b06718f 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -30,6 +30,7 @@ set(command_SRCS
    commands.cpp
    console.cpp
    pipeline.cpp
+    domainadaptor.cpp
    resource.cpp
    resourceaccess.cpp
    storage_common.cpp
diff --git a/common/clientapi.cpp b/common/clientapi.cpp
index 6f0b421..48de1b0 100644
--- a/common/clientapi.cpp
+++ b/common/clientapi.cpp
@@ -14,24 +14,24 @@ namespace async
 namespace Akonadi2
 {
-namespace Domain
+namespace ApplicationDomain
 {
 template<>
-QString getTypeName<Event>()
+QByteArray getTypeName<Event>()
 {
    return "event";
 }
 template<>
-QString getTypeName<Todo>()
+QByteArray getTypeName<Todo>()
 {
    return "todo";
 }
 } // namespace Domain
-void Store::shutdown(const QString &identifier)
+void Store::shutdown(const QByteArray &identifier)
 {
    Akonadi2::ResourceAccess resourceAccess(identifier);
    //FIXME this starts the resource, just to shut it down again if it's not running in the first place.
diff --git a/common/clientapi.h b/common/clientapi.h
index 63305ab..22448b3 100644
--- a/common/clientapi.h
+++ b/common/clientapi.h
@@ -163,7 +163,7 @@ namespace async {
 namespace Akonadi2 {
 /**
- * Standardized Domain Types
+ * Standardized Application Domain Types
 *
 * They don't adhere to any standard and can be freely extended
 * Their sole purpose is providing a standardized interface to access data.
@@ -172,7 +172,7 @@ namespace Akonadi2 {
 *
 * These types will be frequently modified (for every new feature that should be exposed to the any client)
 */
-namespace Domain {
+namespace ApplicationDomain {
 /**
 * This class has to be implemented by resources and can be used as generic interface to access the buffer properties
@@ -180,9 +180,9 @@ namespace Domain {
 class BufferAdaptor {
 public:
    virtual ~BufferAdaptor() {}
-    virtual QVariant getProperty(const QString &key) const { return QVariant(); }
+    virtual QVariant getProperty(const QByteArray &key) const { return QVariant(); }
-    virtual void setProperty(const QString &key, const QVariant &value) {}
+    virtual void setProperty(const QByteArray &key, const QVariant &value) {}
-    virtual QStringList availableProperties() const { return QStringList(); }
+    virtual QList<QByteArray> availableProperties() const { return QList<QByteArray>(); }
 };
 class MemoryBufferAdaptor : public BufferAdaptor {
@@ -202,12 +202,12 @@ public:
    virtual ~MemoryBufferAdaptor() {}
-    virtual QVariant getProperty(const QString &key) const { return mValues.value(key); }
+    virtual QVariant getProperty(const QByteArray &key) const { return mValues.value(key); }
-    virtual void setProperty(const QString &key, const QVariant &value) { mValues.insert(key, value); }
+    virtual void setProperty(const QByteArray &key, const QVariant &value) { mValues.insert(key, value); }
-    virtual QStringList availableProperties() const { return mValues.keys(); }
+    virtual QByteArrayList availableProperties() const { return mValues.keys(); }
 private:
-    QHash<QString, QVariant> mValues;
+    QHash<QByteArray, QVariant> mValues;
 };
 /**
@@ -215,14 +215,14 @@ private:
 * * provide a unified interface to read buffers (for zero-copy reading)
 * * record changes to generate changesets for modifications
 */
-class AkonadiDomainType {
+class ApplicationDomainType {
 public:
-    AkonadiDomainType()
+    ApplicationDomainType()
        :mAdaptor(new MemoryBufferAdaptor())
    {
    }
-    AkonadiDomainType(const QString &resourceName, const QString &identifier, qint64 revision, const QSharedPointer<BufferAdaptor> &adaptor)
+    ApplicationDomainType(const QByteArray &resourceName, const QByteArray &identifier, qint64 revision, const QSharedPointer<BufferAdaptor> &adaptor)
        : mAdaptor(adaptor),
        mResourceName(resourceName),
        mIdentifier(identifier),
@@ -230,41 +230,43 @@ public:
    {
    }
-    virtual ~AkonadiDomainType() {}
+    virtual ~ApplicationDomainType() {}
-    virtual QVariant getProperty(const QString &key) const { return mAdaptor->getProperty(key); }
+    virtual QVariant getProperty(const QByteArray &key) const { return mAdaptor->getProperty(key); }
-    virtual void setProperty(const QString &key, const QVariant &value){ mChangeSet.insert(key, value); mAdaptor->setProperty(key, value); }
+    virtual void setProperty(const QByteArray &key, const QVariant &value){ mChangeSet.insert(key, value); mAdaptor->setProperty(key, value); }
+    virtual QByteArrayList changedProperties() const { return mChangeSet.keys(); }
+    qint64 revision() const { return mRevision; }
 private:
    QSharedPointer<BufferAdaptor> mAdaptor;
-    QHash<QString, QVariant> mChangeSet;
+    QHash<QByteArray, QVariant> mChangeSet;
    /*
     * Each domain object needs to store the resource, identifier, revision triple so we can link back to the storage location.
     */
    QString mResourceName;
-    QString mIdentifier;
+    QByteArray mIdentifier;
    qint64 mRevision;
 };
-struct Event : public AkonadiDomainType {
+struct Event : public ApplicationDomainType {
    typedef QSharedPointer<Event> Ptr;
-    using AkonadiDomainType::AkonadiDomainType;
+    using ApplicationDomainType::ApplicationDomainType;
 };
-struct Todo : public AkonadiDomainType {
+struct Todo : public ApplicationDomainType {
    typedef QSharedPointer<Todo> Ptr;
-    using AkonadiDomainType::AkonadiDomainType;
+    using ApplicationDomainType::ApplicationDomainType;
 };
-struct Calendar : public AkonadiDomainType {
+struct Calendar : public ApplicationDomainType {
    typedef QSharedPointer<Calendar> Ptr;
-    using AkonadiDomainType::AkonadiDomainType;
+    using ApplicationDomainType::ApplicationDomainType;
 };
-class Mail : public AkonadiDomainType {
+class Mail : public ApplicationDomainType {
 };
-class Folder : public AkonadiDomainType {
+class Folder : public ApplicationDomainType {
 };
 /**
@@ -274,13 +276,13 @@ class Folder : public AkonadiDomainType {
 */
 template<class DomainType>
-QString getTypeName();
+QByteArray getTypeName();
 template<>
-QString getTypeName<Event>();
+QByteArray getTypeName<Event>();
 template<>
-QString getTypeName<Todo>();
+QByteArray getTypeName<Todo>();
 }
@@ -298,19 +300,22 @@ using namespace async;
 * * what resources to search
 * * filters on various properties (parent collection, startDate range, ....)
 * * properties we need (for on-demand querying)
+ * 
+ * syncOnDemand: Execute a source sync before executing the query
+ * processAll: Ensure all local messages are processed before querying to guarantee an up-to date dataset.
 */
 class Query
 {
 public:
    Query() : syncOnDemand(true), processAll(false) {}
    //Could also be a propertyFilter
-    QStringList resources;
+    QByteArrayList resources;
    //Could also be a propertyFilter
-    QStringList ids;
+    QByteArrayList ids;
    //Filters to apply
-    QHash<QString, QVariant> propertyFilter;
+    QHash<QByteArray, QVariant> propertyFilter;
    //Properties to retrieve
-    QSet<QString> requestedProperties;
+    QSet<QByteArray> requestedProperties;
    bool syncOnDemand;
    bool processAll;
 };
@@ -328,7 +333,7 @@ template<class DomainType>
 class StoreFacade {
 public:
    virtual ~StoreFacade(){};
-    QString type() const { return Domain::getTypeName<DomainType>(); }
+    QByteArray type() const { return ApplicationDomain::getTypeName<DomainType>(); }
    virtual Async::Job<void> create(const DomainType &domainObject) = 0;
    virtual Async::Job<void> modify(const DomainType &domainObject) = 0;
    virtual Async::Job<void> remove(const DomainType &domainObject) = 0;
@@ -351,15 +356,15 @@ public:
        return factory;
    }
-    static QString key(const QString &resource, const QString &type)
+    static QByteArray key(const QByteArray &resource, const QByteArray &type)
    {
        return resource + type;
    }
    template<class DomainType, class Facade>
-    void registerFacade(const QString &resource)
+    void registerFacade(const QByteArray &resource)
    {
-        const QString typeName = Domain::getTypeName<DomainType>();
+        const QByteArray typeName = ApplicationDomain::getTypeName<DomainType>();
        mFacadeRegistry.insert(key(resource, typeName), [](){ return new Facade; });
    }
@@ -373,16 +378,16 @@ public:
     * FIXME the factory function should really be returning QSharedPointer<void>, which doesn't work (std::shared_pointer<void> would though). That way i.e. a test could keep the object alive until it's done.
     */
    template<class DomainType, class Facade>
-    void registerFacade(const QString &resource, const std::function<void*(void)> &customFactoryFunction)
+    void registerFacade(const QByteArray &resource, const std::function<void*(void)> &customFactoryFunction)
    {
-        const QString typeName = Domain::getTypeName<DomainType>();
+        const QByteArray typeName = ApplicationDomain::getTypeName<DomainType>();
        mFacadeRegistry.insert(key(resource, typeName), customFactoryFunction);
    }
    template<class DomainType>
-    QSharedPointer<StoreFacade<DomainType> > getFacade(const QString &resource)
+    QSharedPointer<StoreFacade<DomainType> > getFacade(const QByteArray &resource)
    {
-        const QString typeName = Domain::getTypeName<DomainType>();
+        const QByteArray typeName = ApplicationDomain::getTypeName<DomainType>();
        auto factoryFunction = mFacadeRegistry.value(key(resource, typeName));
        if (factoryFunction) {
            return QSharedPointer<StoreFacade<DomainType> >(static_cast<StoreFacade<DomainType>* >(factoryFunction()));
@@ -392,7 +397,7 @@ public:
    }
 private:
-    QHash<QString, std::function<void*(void)> > mFacadeRegistry;
+    QHash<QByteArray, std::function<void*(void)> > mFacadeRegistry;
 };
 /**
@@ -421,7 +426,7 @@ public:
            // query tells us in which resources we're interested
            // TODO: queries to individual resources could be parallelized
            Async::Job<void> job = Async::null<void>();
-            for(const QString &resource : query.resources) {
+            for(const QByteArray &resource : query.resources) {
                auto facade = FacadeFactory::instance().getFacade<DomainType>(resource);
                //We have to bind an instance to the function callback. Since we use a shared pointer this keeps the result provider instance (and thus also the emitter) alive.
                std::function<void(const typename DomainType::Ptr &)> addCallback = std::bind(&ResultProvider<typename DomainType::Ptr>::add, resultSet, std::placeholders::_1);
@@ -460,7 +465,7 @@ public:
     */
    //TODO return job that tracks progress until resource has stored the message in it's queue?
    template <class DomainType>
-    static void create(const DomainType &domainObject, const QString &resourceIdentifier) {
+    static void create(const DomainType &domainObject, const QByteArray &resourceIdentifier) {
        //Potentially move to separate thread as well
        auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
        auto job = facade->create(domainObject);
@@ -475,7 +480,7 @@ public:
     * This includes moving etc. since these are also simple settings on a property.
     */
    template <class DomainType>
-    static void modify(const DomainType &domainObject, const QString &resourceIdentifier) {
+    static void modify(const DomainType &domainObject, const QByteArray &resourceIdentifier) {
        //Potentially move to separate thread as well
        auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
        facade.modify(domainObject);
@@ -485,13 +490,13 @@ public:
     * Remove an entity.
     */
    template <class DomainType>
-    static void remove(const DomainType &domainObject, const QString &resourceIdentifier) {
+    static void remove(const DomainType &domainObject, const QByteArray &resourceIdentifier) {
        //Potentially move to separate thread as well
        auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
        facade.remove(domainObject);
    }
-    static void shutdown(const QString &resourceIdentifier);
+    static void shutdown(const QByteArray &resourceIdentifier);
 };
 }
diff --git a/common/domain/event.fbs b/common/domain/event.fbs
index 49ff270..0c6628b 100644
--- a/common/domain/event.fbs
+++ b/common/domain/event.fbs
@@ -1,4 +1,4 @@
-namespace Akonadi2.Domain.Buffer;
+namespace Akonadi2.ApplicationDomain.Buffer;
 table Event {
  uid:string;
diff --git a/common/domainadaptor.cpp b/common/domainadaptor.cpp
new file mode 100644
index 0000000..aa8c3d9
--- /dev/null
+++ b/common/domainadaptor.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2015 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+#include "domainadaptor.h"
+template <>
+flatbuffers::uoffset_t extractProperty<QString>(const QVariant &property, flatbuffers::FlatBufferBuilder &fbb)
+{
+    if (property.isValid()) {
+        return fbb.CreateString(property.toString().toStdString()).o;
+    }
+    return 0;
+}
+template <>
+QSharedPointer<ReadPropertyMapper<Akonadi2::ApplicationDomain::Buffer::Event> > initializeReadPropertyMapper<Akonadi2::ApplicationDomain::Buffer::Event>()
+{
+    auto propertyMapper = QSharedPointer<ReadPropertyMapper<Akonadi2::ApplicationDomain::Buffer::Event> >::create();
+    propertyMapper->addMapping("summary", [](Akonadi2::ApplicationDomain::Buffer::Event const *buffer) -> QVariant {
+        if (buffer->summary()) {
+            return QString::fromStdString(buffer->summary()->c_str());
+        }
+        return QVariant();
+    });
+    propertyMapper->addMapping("uid", [](Akonadi2::ApplicationDomain::Buffer::Event const *buffer) -> QVariant {
+        if (buffer->uid()) {
+            return QString::fromStdString(buffer->uid()->c_str());
+        }
+        return QVariant();
+    });
+    return propertyMapper;
+}
+template <>
+QSharedPointer<WritePropertyMapper<Akonadi2::ApplicationDomain::Buffer::EventBuilder> > initializeWritePropertyMapper<Akonadi2::ApplicationDomain::Buffer::EventBuilder>()
+{
+    auto propertyMapper = QSharedPointer<WritePropertyMapper<Akonadi2::ApplicationDomain::Buffer::EventBuilder> >::create();
+    propertyMapper->addMapping("summary", [](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(Akonadi2::ApplicationDomain::Buffer::EventBuilder &)> {
+        auto offset = extractProperty<QString>(value, fbb);
+        return [offset](Akonadi2::ApplicationDomain::Buffer::EventBuilder &builder) { builder.add_summary(offset); };
+    });
+    propertyMapper->addMapping("uid", [](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(Akonadi2::ApplicationDomain::Buffer::EventBuilder &)> {
+        auto offset = extractProperty<QString>(value, fbb);
+        return [offset](Akonadi2::ApplicationDomain::Buffer::EventBuilder &builder) { builder.add_uid(offset); };
+    });
+    return propertyMapper;
+}
diff --git a/common/domainadaptor.h b/common/domainadaptor.h
index e46e893..e356692 100644
--- a/common/domainadaptor.h
+++ b/common/domainadaptor.h
@@ -21,59 +21,194 @@
 #include "entity_generated.h"
 #include <QVariant>
-#include <QString>
+#include <QByteArray>
 #include <functional>
 #include "clientapi.h" //for domain parts
+#include "event_generated.h"
+#include "entity_generated.h"
+#include "metadata_generated.h"
+#include "entitybuffer.h"
 /**
- * The property mapper holds accessor functions for all properties.
+ * The property mapper is a non-typesafe virtual dispatch.
 *
- * It is by default initialized with accessors that access the local-only buffer,
+ * Instead of using an interface and requring each implementation to override
- * and resource simply have to overwrite those accessors.
+ * a virtual method per property, the property mapper can be filled with accessors
+ * that extract the properties from resource types.
 */
 template<typename BufferType>
-class PropertyMapper
+class ReadPropertyMapper
+{
+public:
+    virtual QVariant getProperty(const QByteArray &key, BufferType const *buffer) const
+    {
+        if (mReadAccessors.contains(key)) {
+            auto accessor = mReadAccessors.value(key);
+            return accessor(buffer);
+        }
+        return QVariant();
+    }
+    bool hasMapping(const QByteArray &key) const { return mReadAccessors.contains(key); }
+    QList<QByteArray> availableProperties() const { return mReadAccessors.keys(); }
+    void addMapping(const QByteArray &property, const std::function<QVariant(BufferType const *)> &mapping) {
+        mReadAccessors.insert(property, mapping);
+    }
+private:
+    QHash<QByteArray, std::function<QVariant(BufferType const *)> > mReadAccessors;
+};
+template<typename BufferBuilder>
+class WritePropertyMapper
 {
 public:
-    void setProperty(const QString &key, const QVariant &value, BufferType *buffer)
+    virtual void setProperty(const QByteArray &key, const QVariant &value, QList<std::function<void(BufferBuilder &)> > &builderCalls, flatbuffers::FlatBufferBuilder &fbb) const
    {
        if (mWriteAccessors.contains(key)) {
            auto accessor = mWriteAccessors.value(key);
-            return accessor(value, buffer);
+            builderCalls << accessor(value, fbb);
        }
    }
+    bool hasMapping(const QByteArray &key) const { return mWriteAccessors.contains(key); }
+    void addMapping(const QByteArray &property, const std::function<std::function<void(BufferBuilder &)>(const QVariant &, flatbuffers::FlatBufferBuilder &)> &mapping) {
+        mWriteAccessors.insert(property, mapping);
+    }
+private:
+    QHash<QByteArray, std::function<std::function<void(BufferBuilder &)>(const QVariant &, flatbuffers::FlatBufferBuilder &)> > mWriteAccessors;
+};
+/**
+ * Defines how to convert qt primitives to flatbuffer ones
+ * TODO: rename to createProperty or so?
+ */
+template <class T>
+flatbuffers::uoffset_t extractProperty(const QVariant &, flatbuffers::FlatBufferBuilder &fbb);
+/**
+ * Create a buffer from a domain object using the provided mappings
+ */
+template <class Builder, class Buffer>
+flatbuffers::Offset<Buffer> createBufferPart(const Akonadi2::ApplicationDomain::ApplicationDomainType &domainObject, flatbuffers::FlatBufferBuilder &fbb, const WritePropertyMapper<Builder> &mapper)
+{
+    //First create a primitives such as strings using the mappings
+    QList<std::function<void(Builder &)> > propertiesToAddToResource;
+    for (const auto &property : domainObject.changedProperties()) {
+        qWarning() << "copying property " << property;
+        const auto value = domainObject.getProperty(property);
+        if (mapper.hasMapping(property)) {
+            mapper.setProperty(property, domainObject.getProperty(property), propertiesToAddToResource, fbb);
+        } else {
+            qWarning() << "no mapping for property available " << property;
+        }
+    }
+    //Then create all porperties using the above generated builderCalls
+    Builder builder(fbb);
+    for (auto propertyBuilder : propertiesToAddToResource) {
+        propertyBuilder(builder);
+    }
+    return builder.Finish();
+}
+/**
+ * A generic adaptor implementation that uses a property mapper to read/write values.
+ * 
+ * TODO: this is the read-only part. Create a write only equivalent
+ */
+template <class LocalBuffer, class ResourceBuffer>
+class GenericBufferAdaptor : public Akonadi2::ApplicationDomain::BufferAdaptor
+{
+public:
+    GenericBufferAdaptor()
+        : BufferAdaptor()
+    {
+    }
-    virtual QVariant getProperty(const QString &key, BufferType const *buffer) const
+    //TODO remove
+    void setProperty(const QByteArray &key, const QVariant &value)
    {
-        if (mReadAccessors.contains(key)) {
+    }
-            auto accessor = mReadAccessors.value(key);
-            return accessor(buffer);
+    virtual QVariant getProperty(const QByteArray &key) const
+    {
+        if (mResourceBuffer && mResourceMapper->hasMapping(key)) {
+            return mResourceMapper->getProperty(key, mResourceBuffer);
+        } else if (mLocalBuffer && mLocalMapper->hasMapping(key)) {
+            return mLocalMapper->getProperty(key, mLocalBuffer);
        }
+        qWarning() << "no mapping available for key " << key;
        return QVariant();
    }
-    QHash<QString, std::function<QVariant(BufferType const *)> > mReadAccessors;
-    QHash<QString, std::function<void(const QVariant &, BufferType*)> > mWriteAccessors;
+    virtual QList<QByteArray> availableProperties() const
+    {
+        QList<QByteArray> props;
+        props << mResourceMapper->availableProperties();
+        props << mLocalMapper->availableProperties();
+        return props;
+    }
+    LocalBuffer const *mLocalBuffer;
+    ResourceBuffer const *mResourceBuffer;
+    QSharedPointer<ReadPropertyMapper<LocalBuffer> > mLocalMapper;
+    QSharedPointer<ReadPropertyMapper<ResourceBuffer> > mResourceMapper;
 };
-//The factory should define how to go from an entitybuffer (local + resource buffer), to a domain type adapter.
+/**
-//It defines how values are split accross local and resource buffer.
+ * Initializes the local property mapper.
-//This is required by the facade the read the value, and by the pipeline preprocessors to access the domain values in a generic way.
+ *
-// template<typename DomainType, typename LocalBuffer, typename ResourceBuffer>
+ * Provide an implementation for each application domain type.
-// class DomainTypeAdaptorFactory
+ */
-// {
+template <class T>
-// };
+QSharedPointer<ReadPropertyMapper<T> > initializeReadPropertyMapper();
+template <class T>
+QSharedPointer<WritePropertyMapper<T> > initializeWritePropertyMapper();
-template<typename DomainType, typename LocalBuffer, typename ResourceBuffer>
+/**
-class DomainTypeAdaptorFactory/* <typename DomainType, LocalBuffer, ResourceBuffer> */
+ * The factory should define how to go from an entitybuffer (local + resource buffer), to a domain type adapter.
+ * It defines how values are split accross local and resource buffer.
+ * This is required by the facade the read the value, and by the pipeline preprocessors to access the domain values in a generic way.
+ */
+template<typename DomainType, typename LocalBuffer, typename ResourceBuffer, typename LocalBuilder, typename ResourceBuilder>
+class DomainTypeAdaptorFactory
 {
 public:
+    DomainTypeAdaptorFactory() :
+        mLocalMapper(initializeReadPropertyMapper<LocalBuffer>()),
+        mResourceMapper(QSharedPointer<ReadPropertyMapper<ResourceBuffer> >::create()),
+        mLocalWriteMapper(initializeWritePropertyMapper<LocalBuilder>()),
+        mResourceWriteMapper(QSharedPointer<WritePropertyMapper<ResourceBuilder> >::create())
+    {};
    virtual ~DomainTypeAdaptorFactory() {};
-    virtual QSharedPointer<Akonadi2::Domain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity) = 0;
-    virtual void createBuffer(const Akonadi2::Domain::Event &event, flatbuffers::FlatBufferBuilder &fbb) {};
+    /**
+     * Creates an adaptor for the given domain and resource types.
+     * 
+     * This returns by default a GenericBufferAdaptor initialized with the corresponding property mappers.
+     */
+    virtual QSharedPointer<Akonadi2::ApplicationDomain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity)
+    {
+        const auto resourceBuffer = Akonadi2::EntityBuffer::readBuffer<ResourceBuffer>(entity.resource());
+        const auto localBuffer = Akonadi2::EntityBuffer::readBuffer<LocalBuffer>(entity.local());
+        // const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(entity.metadata());
+        auto adaptor = QSharedPointer<GenericBufferAdaptor<LocalBuffer, ResourceBuffer> >::create();
+        adaptor->mLocalBuffer = localBuffer;
+        adaptor->mLocalMapper = mLocalMapper;
+        adaptor->mResourceBuffer = resourceBuffer;
+        adaptor->mResourceMapper = mResourceMapper;
+        return adaptor;
+    }
+    virtual void createBuffer(const Akonadi2::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb) {};
 protected:
-    QSharedPointer<PropertyMapper<LocalBuffer> > mLocalMapper;
+    QSharedPointer<ReadPropertyMapper<LocalBuffer> > mLocalMapper;
-    QSharedPointer<PropertyMapper<ResourceBuffer> > mResourceMapper;
+    QSharedPointer<ReadPropertyMapper<ResourceBuffer> > mResourceMapper;
+    QSharedPointer<WritePropertyMapper<LocalBuilder> > mLocalWriteMapper;
+    QSharedPointer<WritePropertyMapper<ResourceBuilder> > mResourceWriteMapper;
 };
diff --git a/common/entitybuffer.cpp b/common/entitybuffer.cpp
index 5ba4afe..b555ac3 100644
--- a/common/entitybuffer.cpp
+++ b/common/entitybuffer.cpp
@@ -56,17 +56,24 @@ void EntityBuffer::extractResourceBuffer(void *dataValue, int dataSize, const st
    }
 }
-void EntityBuffer::assembleEntityBuffer(flatbuffers::FlatBufferBuilder &fbb, void const *metadataData, size_t metadataSize, void const *resourceData, size_t resourceSize, void const *localData, size_t localSize)
+flatbuffers::Offset<flatbuffers::Vector<uint8_t> > EntityBuffer::appendAsVector(flatbuffers::FlatBufferBuilder &fbb, void const *data, size_t size)
 {
-    auto metadata = fbb.CreateVector<uint8_t>(static_cast<uint8_t const*>(metadataData), metadataSize);
+    //Since we do memcpy trickery, this will only work on little endian
-    auto resource = fbb.CreateVector<uint8_t>(static_cast<uint8_t const*>(resourceData), resourceSize);
+    assert(FLATBUFFERS_LITTLEENDIAN);
-    auto local = fbb.CreateVector<uint8_t>(static_cast<uint8_t const*>(localData), localSize);
+    auto metadata = fbb.CreateUninitializedVector<uint8_t>(size);
-    auto builder = Akonadi2::EntityBuilder(fbb);
+    {
-    builder.add_metadata(metadata);
+        auto ptr = reinterpret_cast<flatbuffers::Vector<uint8_t> *>(fbb.GetBufferPointer())->Data();
-    builder.add_resource(resource);
+        std::memcpy((void*)ptr, data, size);
-    builder.add_local(local);
+    }
+    return metadata;
+}
-    auto buffer = builder.Finish();
+void EntityBuffer::assembleEntityBuffer(flatbuffers::FlatBufferBuilder &fbb, void const *metadataData, size_t metadataSize, void const *resourceData, size_t resourceSize, void const *localData, size_t localSize)
-    Akonadi2::FinishEntityBuffer(fbb, buffer);
+{
+    auto metadata = appendAsVector(fbb, metadataData, metadataSize);
+    auto resource = appendAsVector(fbb, resourceData, resourceSize);
+    auto local = appendAsVector(fbb, localData, localSize);
+    auto entity = Akonadi2::CreateEntity(fbb, metadata, resource, local);
+    Akonadi2::FinishEntityBuffer(fbb, entity);
 }
diff --git a/common/entitybuffer.h b/common/entitybuffer.h
index 097b450..82152c9 100644
--- a/common/entitybuffer.h
+++ b/common/entitybuffer.h
@@ -15,7 +15,33 @@ public:
    const Entity &entity();
    static void extractResourceBuffer(void *dataValue, int dataSize, const std::function<void(const uint8_t *, size_t size)> &handler);
+    /*
+     * TODO: Ideally we would be passing references to vectors in the same bufferbuilder, to avoid needlessly copying data.
+     * Unfortunately I couldn't find a way to cast a table to a vector<uint8_t> reference.
+     * We can't use union's either (which would allow to have a field that stores a selection of tables), as we don't want to modify
+     * the entity schema for each resource's buffers.
+     */
    static void assembleEntityBuffer(flatbuffers::FlatBufferBuilder &fbb, void const *metadataData, size_t metadataSize, void const *resourceData, size_t resourceSize, void const *localData, size_t localSize);
+    static flatbuffers::Offset<flatbuffers::Vector<uint8_t> > appendAsVector(flatbuffers::FlatBufferBuilder &fbb, void const *data, size_t size);
+    template<typename T>
+    static const T *readBuffer(const uint8_t *data, int size)
+    {
+        flatbuffers::Verifier verifier(data, size);
+        if (verifier.VerifyBuffer<T>()) {
+            return flatbuffers::GetRoot<T>(data);
+        }
+        return nullptr;
+    }
+    template<typename T>
+    static const T *readBuffer(const flatbuffers::Vector<uint8_t> *data)
+    {
+        if (data) {
+            return readBuffer<T>(data->Data(), data->size());
+        }
+        return nullptr;
+    }
 private:
    const Entity *mEntity;
diff --git a/common/facade.h b/common/facade.h
new file mode 100644
index 0000000..98bcb38
--- /dev/null
+++ b/common/facade.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2014 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+#pragma once
+#include "clientapi.h"
+#include <QByteArray>
+#include "async/src/async.h"
+#include "resourceaccess.h"
+#include "commands.h"
+#include "createentity_generated.h"
+#include "domainadaptor.h"
+#include "entitybuffer.h"
+namespace Akonadi2 {
+    class ResourceAccess;
+/**
+ * Default facade implementation for resources that are implemented in a separate process using the ResourceAccess class.
+ */
+template <typename DomainType>
+class GenericFacade: public Akonadi2::StoreFacade<DomainType>
+{
+public:
+    GenericFacade(const QByteArray &resourceIdentifier)
+        : Akonadi2::StoreFacade<DomainType>(),
+        mResourceAccess(new ResourceAccess(resourceIdentifier))
+    {
+    }
+    ~GenericFacade()
+    {
+    }
+protected:
+    Async::Job<void> sendCreateCommand(const QByteArray &t, const QByteArray &buffer)
+    {
+        flatbuffers::FlatBufferBuilder fbb;
+        //This is the resource buffer type and not the domain type
+        auto type = fbb.CreateString(t.constData());
+        auto delta = Akonadi2::EntityBuffer::appendAsVector(fbb, buffer.constData(), buffer.size());
+        auto location = Akonadi2::Commands::CreateCreateEntity(fbb, type, delta);
+        Akonadi2::Commands::FinishCreateEntityBuffer(fbb, location);
+        mResourceAccess->open();
+        return mResourceAccess->sendCommand(Akonadi2::Commands::CreateEntityCommand, fbb);
+    }
+    Async::Job<void> synchronizeResource(bool sync, bool processAll)
+    {
+        //TODO check if a sync is necessary
+        //TODO Only sync what was requested
+        //TODO timeout
+        //TODO the synchronization should normally not be necessary: We just return what is already available.
+        if (sync || processAll) {
+            return Async::start<void>([=](Async::Future<void> &future) {
+                mResourceAccess->open();
+                mResourceAccess->synchronizeResource(sync, processAll).then<void>([&future]() {
+                    future.setFinished();
+                }).exec();
+            });
+        }
+        return Async::null<void>();
+    }
+private:
+    //TODO use one resource access instance per application => make static
+    QSharedPointer<Akonadi2::ResourceAccess> mResourceAccess;
+};
+}
diff --git a/common/resource.h b/common/resource.h
index bcce229..18a6827 100644
--- a/common/resource.h
+++ b/common/resource.h
@@ -26,10 +26,12 @@
 namespace Akonadi2
 {
+/**
+ * Resource interface
+ */
 class AKONADI2COMMON_EXPORT Resource
 {
 public:
-    //TODO: configuration
    Resource();
    virtual ~Resource();
@@ -44,6 +46,9 @@ private:
    Private * const d;
 };
+/**
+ * Factory interface for resource to implement.
+ */
 class ResourceFactory : public QObject
 {
 public:
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index 7320e50..7a343f9 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -64,8 +64,8 @@ public:
 class ResourceAccess::Private
 {
 public:
-    Private(const QString &name, ResourceAccess *ra);
+    Private(const QByteArray &name, ResourceAccess *ra);
-    QString resourceName;
+    QByteArray resourceName;
    QLocalSocket *socket;
    QTimer *tryOpenTimer;
    bool startingProcess;
@@ -77,7 +77,7 @@ public:
    uint messageId;
 };
-ResourceAccess::Private::Private(const QString &name, ResourceAccess *q)
+ResourceAccess::Private::Private(const QByteArray &name, ResourceAccess *q)
    : resourceName(name),
      socket(new QLocalSocket(q)),
      tryOpenTimer(new QTimer(q)),
@@ -87,7 +87,7 @@ ResourceAccess::Private::Private(const QString &name, ResourceAccess *q)
 {
 }
-ResourceAccess::ResourceAccess(const QString &resourceName, QObject *parent)
+ResourceAccess::ResourceAccess(const QByteArray &resourceName, QObject *parent)
    : QObject(parent),
      d(new Private(resourceName, this))
 {
@@ -112,7 +112,7 @@ ResourceAccess::~ResourceAccess()
 }
-QString ResourceAccess::resourceName() const
+QByteArray ResourceAccess::resourceName() const
 {
    return d->resourceName;
 }
diff --git a/common/resourceaccess.h b/common/resourceaccess.h
index a5a2547..088bf36 100644
--- a/common/resourceaccess.h
+++ b/common/resourceaccess.h
@@ -35,10 +35,10 @@ class ResourceAccess : public QObject
    Q_OBJECT
 public:
-    ResourceAccess(const QString &resourceName, QObject *parent = 0);
+    ResourceAccess(const QByteArray &resourceName, QObject *parent = 0);
    ~ResourceAccess();
-    QString resourceName() const;
+    QByteArray resourceName() const;
    bool isReady() const;
    Async::Job<void> sendCommand(int commandId);
diff --git a/common/storage.h b/common/storage.h
index 78faac0..09365b0 100644
--- a/common/storage.h
+++ b/common/storage.h
@@ -98,7 +98,7 @@ public:
     * Set the default error handler.
     */
    void setDefaultErrorHandler(const std::function<void(const Storage::Error &error)> &errorHandler);
-    std::function<void(const Storage::Error &error)> defaultErrorHandler();
+    std::function<void(const Storage::Error &error)> defaultErrorHandler() const;
    /**
     * A basic error handler that writes to std::cerr.
diff --git a/common/storage_common.cpp b/common/storage_common.cpp
index 5728096..65f6e57 100644
--- a/common/storage_common.cpp
+++ b/common/storage_common.cpp
@@ -46,7 +46,7 @@ void Storage::setDefaultErrorHandler(const std::function<void(const Storage::Err
    mErrorHandler = errorHandler;
 }
-std::function<void(const Storage::Error &error)> Storage::defaultErrorHandler()
+std::function<void(const Storage::Error &error)> Storage::defaultErrorHandler() const
 {
    if (mErrorHandler) {
        return mErrorHandler;
diff --git a/common/storage_lmdb.cpp b/common/storage_lmdb.cpp
index 4fcb11f..7bbf8b5 100644
--- a/common/storage_lmdb.cpp
+++ b/common/storage_lmdb.cpp
@@ -425,11 +425,11 @@ qint64 Storage::diskUsage() const
 void Storage::removeFromDisk() const
 {
    const QString fullPath(d->storageRoot + '/' + d->name);
-    qDebug() << "removing " << fullPath;
    QMutexLocker locker(&d->sMutex);
    QDir dir(fullPath);
    if (!dir.removeRecursively()) {
-        qWarning() << "Failed to remove directory" << d->storageRoot << d->name;
+        Error error(d->name.toLatin1(), ErrorCodes::GenericError, QString("Failed to remove directory %1 %2").arg(d->storageRoot).arg(d->name).toLatin1());
+        defaultErrorHandler()(error);
    }
    auto env = d->sEnvironments.take(fullPath);
    mdb_env_close(env);
diff --git a/common/test/clientapitest.cpp b/common/test/clientapitest.cpp
index c9e4d6d..24b3fb9 100644
--- a/common/test/clientapitest.cpp
+++ b/common/test/clientapitest.cpp
@@ -4,14 +4,14 @@
 #include "../clientapi.h"
-class DummyResourceFacade : public Akonadi2::StoreFacade<Akonadi2::Domain::Event>
+class DummyResourceFacade : public Akonadi2::StoreFacade<Akonadi2::ApplicationDomain::Event>
 {
 public:
    ~DummyResourceFacade(){};
-    virtual Async::Job<void> create(const Akonadi2::Domain::Event &domainObject){ return Async::null<void>(); };
+    virtual Async::Job<void> create(const Akonadi2::ApplicationDomain::Event &domainObject){ return Async::null<void>(); };
-    virtual Async::Job<void> modify(const Akonadi2::Domain::Event &domainObject){ return Async::null<void>(); };
+    virtual Async::Job<void> modify(const Akonadi2::ApplicationDomain::Event &domainObject){ return Async::null<void>(); };
-    virtual Async::Job<void> remove(const Akonadi2::Domain::Event &domainObject){ return Async::null<void>(); };
+    virtual Async::Job<void> remove(const Akonadi2::ApplicationDomain::Event &domainObject){ return Async::null<void>(); };
-    virtual Async::Job<void> load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback)
+    virtual Async::Job<void> load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::ApplicationDomain::Event::Ptr &)> &resultCallback)
    {
        return Async::start<void>([this, resultCallback](Async::Future<void> &future) {
            qDebug() << "load called";
@@ -22,7 +22,7 @@ public:
        });
    }
-    QList<Akonadi2::Domain::Event::Ptr> results;
+    QList<Akonadi2::ApplicationDomain::Event::Ptr> results;
 };
 class ClientAPITest : public QObject
@@ -33,14 +33,14 @@ private Q_SLOTS:
    void testLoad()
    {
        DummyResourceFacade facade;
-        facade.results << QSharedPointer<Akonadi2::Domain::Event>::create("resource", "id", 0, QSharedPointer<Akonadi2::Domain::BufferAdaptor>());
+        facade.results << QSharedPointer<Akonadi2::ApplicationDomain::Event>::create("resource", "id", 0, QSharedPointer<Akonadi2::ApplicationDomain::BufferAdaptor>());
-        Akonadi2::FacadeFactory::instance().registerFacade<Akonadi2::Domain::Event, DummyResourceFacade>("dummyresource", [facade](){ return new DummyResourceFacade(facade); });
+        Akonadi2::FacadeFactory::instance().registerFacade<Akonadi2::ApplicationDomain::Event, DummyResourceFacade>("dummyresource", [facade](){ return new DummyResourceFacade(facade); });
        Akonadi2::Query query;
        query.resources << "dummyresource";
-        async::SyncListResult<Akonadi2::Domain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::Domain::Event>(query));
+        async::SyncListResult<Akonadi2::ApplicationDomain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::ApplicationDomain::Event>(query));
        result.exec();
        QCOMPARE(result.size(), 1);
    }
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();
+    //TODO turn this into initializeReadPropertyMapper as well?
-    mResourceMapper->mReadAccessors.insert("summary", [](DummyEvent const *buffer) -> QVariant {
+    mResourceMapper->addMapping("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 {
        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;
+    flatbuffers::FlatBufferBuilder localFbb;
-    if (auto resourceData = entity.resource()) {
+    if (mLocalWriteMapper) {
-        flatbuffers::Verifier verifyer(resourceData->Data(), resourceData->size());
+        auto pos = createBufferPart<Akonadi2::ApplicationDomain::Buffer::EventBuilder, Akonadi2::ApplicationDomain::Buffer::Event>(event, localFbb, *mLocalWriteMapper);
-        if (VerifyDummyEventBuffer(verifyer)) {
+        Akonadi2::ApplicationDomain::Buffer::FinishEventBuffer(localFbb, pos);
-            resourceBuffer = GetDummyEvent(resourceData->Data());
+        flatbuffers::Verifier verifier(localFbb.GetBufferPointer(), localFbb.GetSize());
+        if (!verifier.VerifyBuffer<Akonadi2::ApplicationDomain::Buffer::Event>()) {
+            Warning() << "Created invalid local buffer";
        }
    }
-    // Akonadi2::Metadata const *metadataBuffer = 0;
+    flatbuffers::FlatBufferBuilder resFbb;
-    // if (auto metadataData = entity.metadata()) {
+    if (mResourceWriteMapper) {
-    //     flatbuffers::Verifier verifyer(metadataData->Data(), metadataData->size());
+        auto pos = createBufferPart<DummyEventBuilder, DummyEvent>(event, resFbb, *mResourceWriteMapper);
-    //     if (Akonadi2::VerifyMetadataBuffer(verifyer)) {
+        DummyCalendar::FinishDummyEventBuffer(resFbb, pos);
-    //         metadataBuffer = Akonadi2::GetMetadata(metadataData->Data());
+        flatbuffers::Verifier verifier(resFbb.GetBufferPointer(), resFbb.GetSize());
-    //     }
+        if (!verifier.VerifyBuffer<DummyEvent>()) {
-    // }
+            Warning() << "Created invalid resource buffer";
-    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());
        }
    }
-    auto adaptor = QSharedPointer<DummyEventAdaptor>::create();
+    Akonadi2::EntityBuffer::assembleEntityBuffer(fbb, 0, 0, resFbb.GetBufferPointer(), resFbb.GetSize(), localFbb.GetBufferPointer(), localFbb.GetSize());
-    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());
 }
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::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb);
-    virtual void createBuffer(const Akonadi2::Domain::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>(),
+    : Akonadi2::GenericFacade<Akonadi2::ApplicationDomain::Event>("org.kde.dummy"),
-    mResourceAccess(new Akonadi2::ResourceAccess("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);
+    return sendCreateCommand("event", QByteArray::fromRawData(reinterpret_cast<const char*>(entityFbb.GetBufferPointer()), entityFbb.GetSize()));
-    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);
 }
-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)
+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)
-{
-    //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)
 {
    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;
+        const auto resourceBuffer = Akonadi2::EntityBuffer::readBuffer<DummyEvent>(buffer.entity().resource());
-        if (auto resourceData = buffer.entity().resource()) {
+        const auto localBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::ApplicationDomain::Buffer::Event>(buffer.entity().local());
-            flatbuffers::Verifier verifyer(resourceData->Data(), resourceData->size());
+        const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(buffer.entity().metadata());
-            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());
-            }
-        }
-        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 memoryAdaptor = QSharedPointer<Akonadi2::ApplicationDomain::MemoryBufferAdaptor>::create(*adaptor);
-            auto event = QSharedPointer<Akonadi2::Domain::Event>::create("org.kde.dummy", QString::fromUtf8(static_cast<char*>(keyValue), keySize), revision, memoryAdaptor);
+            // 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 DummyResourceFacade : public Akonadi2::GenericFacade<Akonadi2::ApplicationDomain::Event>
-    class ResourceAccess;
-}
-class DummyResourceFacade : public Akonadi2::StoreFacade<Akonadi2::Domain::Event>
 {
 public:
    DummyResourceFacade();
    virtual ~DummyResourceFacade();
-    virtual Async::Job<void> create(const Akonadi2::Domain::Event &domainObject);
+    virtual Async::Job<void> create(const Akonadi2::ApplicationDomain::Event &domainObject);
-    virtual Async::Job<void> modify(const Akonadi2::Domain::Event &domainObject);
+    virtual Async::Job<void> modify(const Akonadi2::ApplicationDomain::Event &domainObject);
-    virtual Async::Job<void> remove(const Akonadi2::Domain::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::Domain::Event::Ptr &)> &resultCallback);
+    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)>);
+    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)>);
-    Async::Job<void> synchronizeResource(bool sync, bool processAll);
+    QSharedPointer<DomainTypeAdaptorFactory<Akonadi2::ApplicationDomain::Event, Akonadi2::ApplicationDomain::Buffer::Event, DummyCalendar::DummyEvent, Akonadi2::ApplicationDomain::Buffer::EventBuilder, DummyCalendar::DummyEventBuilder> > mFactory;
-    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 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 commandData = Akonadi2::EntityBuffer::appendAsVector(m_fbb, data.constData(), data.size());
-    auto builder = Akonadi2::QueuedCommandBuilder(m_fbb);
+    auto buffer = Akonadi2::CreateQueuedCommand(m_fbb, commandId, commandData);
-    builder.add_commandId(commandId);
-    builder.add_command(commandData);
-    auto buffer = builder.Finish();
    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"
diff --git a/synchronizer/listener.cpp b/synchronizer/listener.cpp
index 2e1e918..7481537 100644
--- a/synchronizer/listener.cpp
+++ b/synchronizer/listener.cpp
@@ -35,7 +35,7 @@
 #include <QLocalSocket>
 #include <QTimer>
-Listener::Listener(const QString &resourceName, QObject *parent)
+Listener::Listener(const QByteArray &resourceName, QObject *parent)
    : QObject(parent),
      m_server(new QLocalServer(this)),
      m_resourceName(resourceName),
@@ -48,11 +48,11 @@ Listener::Listener(const QString &resourceName, QObject *parent)
            this, &Listener::refreshRevision);
    connect(m_server, &QLocalServer::newConnection,
             this, &Listener::acceptConnection);
-    Log() << QString("Trying to open %1").arg(resourceName);
+    Log() << "Trying to open " << m_resourceName;
-    if (!m_server->listen(resourceName)) {
+    if (!m_server->listen(QString::fromLatin1(resourceName))) {
        // FIXME: multiple starts need to be handled here
        m_server->removeServer(resourceName);
-        if (!m_server->listen(resourceName)) {
+        if (!m_server->listen(QString::fromLatin1(resourceName))) {
            Warning() << "Utter failure to start server";
            exit(-1);
        }
@@ -212,26 +212,16 @@ void Listener::processCommand(int commandId, uint messageId, Client &client, uin
                    Warning() << "No resource loaded";
                    break;
                }
-                //TODO a more elegant composition of jobs should be possible
+                auto job = Async::null<void>();
                if (buffer->sourceSync()) {
-                    bool localSync = buffer->localSync();
+                    job = m_resource->synchronizeWithSource(m_pipeline);
-                    m_resource->synchronizeWithSource(m_pipeline).then<void>([callback, localSync, this](Async::Future<void> &f){
-                        if (localSync) {
-                            m_resource->processAllMessages().then<void>([callback](Async::Future<void> &f){
-                                callback();
-                                f.setFinished();
-                            }).exec();
-                        } else {
-                            callback();
-                            f.setFinished();
-                        }
-                    }).exec();
-                } else if (buffer->localSync()) {
-                    m_resource->processAllMessages().then<void>([callback](Async::Future<void> &f){
-                        callback();
-                        f.setFinished();
-                    }).exec();
                }
+                if (buffer->localSync()) {
+                    job = job.then<void>(m_resource->processAllMessages());
+                }
+                job.then<void>([callback]() {
+                    callback();
+                }).exec();
                return;
            } else {
                Warning() << "received invalid command";
@@ -375,10 +365,10 @@ void Listener::loadResource()
        Log() << QString("Resource factory: %1").arg((qlonglong)resourceFactory);
        Log() << QString("\tResource: %1").arg((qlonglong)m_resource);
        //TODO: this doesn't really list all the facades .. fix
-        Log() << QString("\tFacades: %1").arg(Akonadi2::FacadeFactory::instance().getFacade<Akonadi2::Domain::Event>(m_resourceName)->type());
+        Log() << "\tFacades: " << Akonadi2::FacadeFactory::instance().getFacade<Akonadi2::ApplicationDomain::Event>(m_resourceName)->type();
        m_resource->configurePipeline(m_pipeline);
    } else {
-        Error() << QString("Failed to load resource %1").arg(m_resourceName);
+        Error() << "Failed to load resource " << m_resourceName;
    }
    //TODO: on failure ... what?
    //Enter broken state?
diff --git a/synchronizer/listener.h b/synchronizer/listener.h
index 8dad3a4..d2ef0fc 100644
--- a/synchronizer/listener.h
+++ b/synchronizer/listener.h
@@ -58,7 +58,7 @@ class Listener : public QObject
    Q_OBJECT
 public:
-    Listener(const QString &resourceName, QObject *parent = 0);
+    Listener(const QByteArray &resourceName, QObject *parent = 0);
    ~Listener();
 Q_SIGNALS:
@@ -87,7 +87,7 @@ private:
    QLocalServer *m_server;
    QVector<Client> m_connections;
    flatbuffers::FlatBufferBuilder m_fbb;
-    const QString m_resourceName;
+    const QByteArray m_resourceName;
    Akonadi2::Resource *m_resource;
    Akonadi2::Pipeline *m_pipeline;
    QTimer *m_clientBufferProcessesTimer;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 8257c8a..d3e6870 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -2,6 +2,7 @@ add_subdirectory(hawd)
 set(CMAKE_AUTOMOC ON)
 include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/hawd)
+include_directories (${CMAKE_CURRENT_BINARY_DIR}/../dummyresource)
 generate_flatbuffers(calendar)
@@ -13,14 +14,26 @@ macro(manual_tests)
    endforeach(_testname)
 endmacro(manual_tests)
+macro(auto_tests)
+    foreach(_testname ${ARGN})
+        add_executable(${_testname} ${_testname}.cpp)
+        add_test(${_testname} ${_testname})
+        qt5_use_modules(${_testname} Core Test Concurrent)
+        target_link_libraries(${_testname} akonadi2common libhawd)
+    endforeach(_testname)
+endmacro(auto_tests)
 manual_tests (
    storagebenchmark
+    dummyresourcebenchmark
+)
+auto_tests (
    storagetest
    dummyresourcetest
    domainadaptortest
    messagequeuetest
    indextest
-    dummyresourcebenchmark
 )
 target_link_libraries(dummyresourcetest akonadi2_resource_dummy)
diff --git a/tests/domainadaptortest.cpp b/tests/domainadaptortest.cpp
index cedbf94..1e285dc 100644
--- a/tests/domainadaptortest.cpp
+++ b/tests/domainadaptortest.cpp
@@ -13,89 +13,12 @@
 #include "metadata_generated.h"
 #include "entity_generated.h"
-class TestEventAdaptor : public Akonadi2::Domain::BufferAdaptor
+class TestFactory : public DomainTypeAdaptorFactory<Akonadi2::ApplicationDomain::Event, Akonadi2::ApplicationDomain::Buffer::Event, Akonadi2::ApplicationDomain::Buffer::Event, Akonadi2::ApplicationDomain::Buffer::EventBuilder, Akonadi2::ApplicationDomain::Buffer::EventBuilder>
-{
-public:
-    TestEventAdaptor()
-        : Akonadi2::Domain::BufferAdaptor()
-    {
-    }
-    void setProperty(const QString &key, const QVariant &value)
-    {
-        if (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) {
-            return mLocalMapper->getProperty(key, mLocalBuffer);
-        }
-        return QVariant();
-    }
-    Akonadi2::Domain::Buffer::Event const *mLocalBuffer;
-    Akonadi2::Domain::Buffer::Event const *mResourceBuffer;
-    QSharedPointer<PropertyMapper<Akonadi2::Domain::Buffer::Event> > mLocalMapper;
-    QSharedPointer<PropertyMapper<Akonadi2::Domain::Buffer::Event> > mResourceMapper;
-};
-class TestFactory : public DomainTypeAdaptorFactory<Akonadi2::Domain::Event, Akonadi2::Domain::Buffer::Event, Akonadi2::Domain::Buffer::Event>
 {
 public:
    TestFactory()
    {
-        mResourceMapper = QSharedPointer<PropertyMapper<Akonadi2::Domain::Buffer::Event> >::create();
+        mResourceWriteMapper = initializeWritePropertyMapper<Akonadi2::ApplicationDomain::Buffer::EventBuilder>();
-        mResourceMapper->mReadAccessors.insert("summary", [](Akonadi2::Domain::Buffer::Event const *buffer) -> QVariant {
-            if (buffer->summary()) {
-                return QString::fromStdString(buffer->summary()->c_str());
-            }
-            return QVariant();
-        });
-    }
-    virtual QSharedPointer<Akonadi2::Domain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity)
-    {
-        Akonadi2::Domain::Buffer::Event const *resourceBuffer = 0;
-        if (auto resourceData = entity.resource()) {
-            flatbuffers::Verifier verifyer(resourceData->Data(), resourceData->size());
-            if (Akonadi2::Domain::Buffer::VerifyEventBuffer(verifyer)) {
-                resourceBuffer = Akonadi2::Domain::Buffer::GetEvent(resourceData->Data());
-                if (resourceBuffer->summary()) {
-                    qDebug() << QString::fromStdString(std::string(resourceBuffer->summary()->c_str()));
-                }
-            }
-        }
-        // 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);
-        //     }
-        // }
-        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);
-            }
-        }
-        auto adaptor = QSharedPointer<TestEventAdaptor>::create();
-        adaptor->mLocalBuffer = localBuffer;
-        adaptor->mResourceBuffer = resourceBuffer;
-        adaptor->mResourceMapper = mResourceMapper;
-        adaptor->mLocalMapper = mLocalMapper;
-        return adaptor;
    }
 };
@@ -111,6 +34,21 @@ private Q_SLOTS:
    {
    }
+    void testCreateBufferPart()
+    {
+        auto writeMapper = initializeWritePropertyMapper<Akonadi2::ApplicationDomain::Buffer::EventBuilder>();
+        Akonadi2::ApplicationDomain::Event event;
+        event.setProperty("summary", "foo");
+        flatbuffers::FlatBufferBuilder fbb;
+        auto pos = createBufferPart<Akonadi2::ApplicationDomain::Buffer::EventBuilder, Akonadi2::ApplicationDomain::Buffer::Event>(event, fbb, *writeMapper);
+        Akonadi2::ApplicationDomain::Buffer::FinishEventBuffer(fbb, pos);
+        flatbuffers::Verifier verifier(fbb.GetBufferPointer(), fbb.GetSize());
+        QVERIFY(verifier.VerifyBuffer<Akonadi2::ApplicationDomain::Buffer::Event>());
+    }
    void testAdaptor()
    {
        //Create entity buffer
@@ -127,12 +65,12 @@ private Q_SLOTS:
        static uint8_t rawData[100];
        auto attachment = m_fbb.CreateVector(rawData, 100);
-        auto builder = Akonadi2::Domain::Buffer::EventBuilder(m_fbb);
+        auto builder = Akonadi2::ApplicationDomain::Buffer::EventBuilder(m_fbb);
        builder.add_summary(summary);
        builder.add_description(description);
        builder.add_attachment(attachment);
        auto buffer = builder.Finish();
-        Akonadi2::Domain::Buffer::FinishEventBuffer(m_fbb, buffer);
+        Akonadi2::ApplicationDomain::Buffer::FinishEventBuffer(m_fbb, buffer);
        flatbuffers::FlatBufferBuilder fbb;
        Akonadi2::EntityBuffer::assembleEntityBuffer(fbb, metadataFbb.GetBufferPointer(), metadataFbb.GetSize(), m_fbb.GetBufferPointer(), m_fbb.GetSize(), m_fbb.GetBufferPointer(), m_fbb.GetSize());
diff --git a/tests/dummyresourcebenchmark.cpp b/tests/dummyresourcebenchmark.cpp
index 01d9ca4..d83cb70 100644
--- a/tests/dummyresourcebenchmark.cpp
+++ b/tests/dummyresourcebenchmark.cpp
@@ -3,10 +3,17 @@
 #include <QString>
 #include "dummyresource/resourcefactory.h"
+#include "dummyresource/domainadaptor.h"
 #include "clientapi.h"
 #include "commands.h"
 #include "entitybuffer.h"
+#include "event_generated.h"
+#include "entity_generated.h"
+#include "metadata_generated.h"
+#include "createentity_generated.h"
+#include <iostream>
 static void removeFromDisk(const QString &name)
 {
    Akonadi2::Storage store(Akonadi2::Store::storageLocation(), name, Akonadi2::Storage::ReadWrite);
@@ -41,11 +48,11 @@ private Q_SLOTS:
        time.start();
        int num = 10000;
        for (int i = 0; i < num; i++) {
-            Akonadi2::Domain::Event event;
+            Akonadi2::ApplicationDomain::Event event;
            event.setProperty("uid", "testuid");
            QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
            event.setProperty("summary", "summaryValue");
-            Akonadi2::Store::create<Akonadi2::Domain::Event>(event, "org.kde.dummy");
+            Akonadi2::Store::create<Akonadi2::ApplicationDomain::Event>(event, "org.kde.dummy");
        }
        auto appendTime = time.elapsed();
@@ -57,7 +64,7 @@ private Q_SLOTS:
            query.processAll = true;
            query.propertyFilter.insert("uid", "nonexistantuid");
-            async::SyncListResult<Akonadi2::Domain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::Domain::Event>(query));
+            async::SyncListResult<Akonadi2::ApplicationDomain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::ApplicationDomain::Event>(query));
            result.exec();
        }
        auto allProcessedTime = time.elapsed();
@@ -71,7 +78,7 @@ private Q_SLOTS:
            query.processAll = false;
            query.propertyFilter.insert("uid", "testuid");
-            async::SyncListResult<Akonadi2::Domain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::Domain::Event>(query));
+            async::SyncListResult<Akonadi2::ApplicationDomain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::ApplicationDomain::Event>(query));
            result.exec();
            QCOMPARE(result.size(), num);
        }
@@ -79,6 +86,85 @@ private Q_SLOTS:
        qDebug() << "All processed: " << allProcessedTime << "/sec " << num*1000/allProcessedTime;
        qDebug() << "Query Time: " << time.elapsed() << "/sec " << num*1000/time.elapsed();
    }
+    void testWriteInProcess()
+    {
+        QTime time;
+        time.start();
+        int num = 10000;
+        Akonadi2::Pipeline pipeline("org.kde.dummy");
+        QSignalSpy revisionSpy(&pipeline, SIGNAL(revisionUpdated()));
+        DummyResource resource;
+        resource.configurePipeline(&pipeline);
+        flatbuffers::FlatBufferBuilder eventFbb;
+        eventFbb.Clear();
+        {
+            auto summary = eventFbb.CreateString("summary");
+            Akonadi2::ApplicationDomain::Buffer::EventBuilder eventBuilder(eventFbb);
+            eventBuilder.add_summary(summary);
+            auto eventLocation = eventBuilder.Finish();
+            Akonadi2::ApplicationDomain::Buffer::FinishEventBuffer(eventFbb, eventLocation);
+        }
+        flatbuffers::FlatBufferBuilder localFbb;
+        {
+            auto uid = localFbb.CreateString("testuid");
+            auto localBuilder = Akonadi2::ApplicationDomain::Buffer::EventBuilder(localFbb);
+            localBuilder.add_uid(uid);
+            auto location = localBuilder.Finish();
+            Akonadi2::ApplicationDomain::Buffer::FinishEventBuffer(localFbb, location);
+        }
+        flatbuffers::FlatBufferBuilder entityFbb;
+        Akonadi2::EntityBuffer::assembleEntityBuffer(entityFbb, 0, 0, eventFbb.GetBufferPointer(), eventFbb.GetSize(), localFbb.GetBufferPointer(), localFbb.GetSize());
+        flatbuffers::FlatBufferBuilder fbb;
+        auto type = fbb.CreateString(Akonadi2::ApplicationDomain::getTypeName<Akonadi2::ApplicationDomain::Event>().toStdString().data());
+        auto delta = fbb.CreateVector<uint8_t>(entityFbb.GetBufferPointer(), entityFbb.GetSize());
+        Akonadi2::Commands::CreateEntityBuilder builder(fbb);
+        builder.add_domainType(type);
+        builder.add_delta(delta);
+        auto location = builder.Finish();
+        Akonadi2::Commands::FinishCreateEntityBuffer(fbb, location);
+        const QByteArray command(reinterpret_cast<const char *>(fbb.GetBufferPointer()), fbb.GetSize());
+        for (int i = 0; i < num; i++) {
+            resource.processCommand(Akonadi2::Commands::CreateEntityCommand, command, command.size(), &pipeline);
+        }
+        auto appendTime = time.elapsed();
+        //Wait until all messages have been processed
+        resource.processAllMessages().exec().waitForFinished();
+        auto allProcessedTime = time.elapsed();
+        std::cout << "Append to messagequeue " << appendTime << std::endl;
+        std::cout << "All processed: " << allProcessedTime << "/sec " << num*1000/allProcessedTime << std::endl;
+    }
+    void testCreateCommand()
+    {
+        Akonadi2::ApplicationDomain::Event event;
+        QBENCHMARK {
+            auto mFactory = new DummyEventAdaptorFactory;
+            static flatbuffers::FlatBufferBuilder entityFbb;
+            entityFbb.Clear();
+            mFactory->createBuffer(event, entityFbb);
+            static flatbuffers::FlatBufferBuilder fbb;
+            fbb.Clear();
+            //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 delta = Akonadi2::EntityBuffer::appendAsVector(fbb, entityFbb.GetBufferPointer(), entityFbb.GetSize());
+            auto location = Akonadi2::Commands::CreateCreateEntity(fbb, type, delta);
+            Akonadi2::Commands::FinishCreateEntityBuffer(fbb, location);
+        }
+    }
 };
 QTEST_MAIN(DummyResourceBenchmark)
diff --git a/tests/dummyresourcetest.cpp b/tests/dummyresourcetest.cpp
index b185664..5fed7cd 100644
--- a/tests/dummyresourcetest.cpp
+++ b/tests/dummyresourcetest.cpp
@@ -49,26 +49,26 @@ private Q_SLOTS:
        eventFbb.Clear();
        {
            auto summary = eventFbb.CreateString("summary");
-            Akonadi2::Domain::Buffer::EventBuilder eventBuilder(eventFbb);
+            Akonadi2::ApplicationDomain::Buffer::EventBuilder eventBuilder(eventFbb);
            eventBuilder.add_summary(summary);
            auto eventLocation = eventBuilder.Finish();
-            Akonadi2::Domain::Buffer::FinishEventBuffer(eventFbb, eventLocation);
+            Akonadi2::ApplicationDomain::Buffer::FinishEventBuffer(eventFbb, eventLocation);
        }
        flatbuffers::FlatBufferBuilder localFbb;
        {
            auto uid = localFbb.CreateString("testuid");
-            auto localBuilder = Akonadi2::Domain::Buffer::EventBuilder(localFbb);
+            auto localBuilder = Akonadi2::ApplicationDomain::Buffer::EventBuilder(localFbb);
            localBuilder.add_uid(uid);
            auto location = localBuilder.Finish();
-            Akonadi2::Domain::Buffer::FinishEventBuffer(localFbb, location);
+            Akonadi2::ApplicationDomain::Buffer::FinishEventBuffer(localFbb, location);
        }
        flatbuffers::FlatBufferBuilder entityFbb;
        Akonadi2::EntityBuffer::assembleEntityBuffer(entityFbb, 0, 0, eventFbb.GetBufferPointer(), eventFbb.GetSize(), localFbb.GetBufferPointer(), localFbb.GetSize());
        flatbuffers::FlatBufferBuilder fbb;
-        auto type = fbb.CreateString(Akonadi2::Domain::getTypeName<Akonadi2::Domain::Event>().toStdString().data());
+        auto type = fbb.CreateString(Akonadi2::ApplicationDomain::getTypeName<Akonadi2::ApplicationDomain::Event>().toStdString().data());
        auto delta = fbb.CreateVector<uint8_t>(entityFbb.GetBufferPointer(), entityFbb.GetSize());
        Akonadi2::Commands::CreateEntityBuilder builder(fbb);
        builder.add_domainType(type);
@@ -98,18 +98,18 @@ private Q_SLOTS:
    void testProperty()
    {
-        Akonadi2::Domain::Event event;
+        Akonadi2::ApplicationDomain::Event event;
        event.setProperty("uid", "testuid");
        QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
    }
    void testWriteToFacadeAndQueryByUid()
    {
-        Akonadi2::Domain::Event event;
+        Akonadi2::ApplicationDomain::Event event;
        event.setProperty("uid", "testuid");
        QCOMPARE(event.getProperty("uid").toByteArray(), QByteArray("testuid"));
        event.setProperty("summary", "summaryValue");
-        Akonadi2::Store::create<Akonadi2::Domain::Event>(event, "org.kde.dummy");
+        Akonadi2::Store::create<Akonadi2::ApplicationDomain::Event>(event, "org.kde.dummy");
        Akonadi2::Query query;
        query.resources << "org.kde.dummy";
@@ -117,7 +117,7 @@ private Q_SLOTS:
        query.processAll = true;
        query.propertyFilter.insert("uid", "testuid");
-        async::SyncListResult<Akonadi2::Domain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::Domain::Event>(query));
+        async::SyncListResult<Akonadi2::ApplicationDomain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::ApplicationDomain::Event>(query));
        result.exec();
        QCOMPARE(result.size(), 1);
        auto value = result.first();
@@ -147,7 +147,7 @@ private Q_SLOTS:
        query.syncOnDemand = true;
        query.processAll = true;
-        async::SyncListResult<Akonadi2::Domain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::Domain::Event>(query));
+        async::SyncListResult<Akonadi2::ApplicationDomain::Event::Ptr> result(Akonadi2::Store::load<Akonadi2::ApplicationDomain::Event>(query));
        result.exec();
        QVERIFY(!result.isEmpty());
        auto value = result.first();