16 files changed, 438 insertions, 108 deletions

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 void setProperty(const QString &key, const QVariant &value) {}
-    virtual QStringList availableProperties() const { return QStringList(); }
+    virtual QVariant getProperty(const QByteArray &key) const { return QVariant(); }
+    virtual void setProperty(const QByteArray &key, const QVariant &value) {}
+    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 void setProperty(const QString &key, const QVariant &value) { mValues.insert(key, value); }
-    virtual QStringList availableProperties() const { return mValues.keys(); }
+    virtual QVariant getProperty(const QByteArray &key) const { return mValues.value(key); }
+    virtual void setProperty(const QByteArray &key, const QVariant &value) { mValues.insert(key, value); }
+    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 void setProperty(const QString &key, const QVariant &value){ mChangeSet.insert(key, value); mAdaptor->setProperty(key, value); }
+    virtual QVariant getProperty(const QByteArray &key) const { return mAdaptor->getProperty(key); }
+    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,
- * and resource simply have to overwrite those accessors.
+ * Instead of using an interface and requring each implementation to override
+ * 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.
-//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>
-// class DomainTypeAdaptorFactory
-// {
-// };
+/**
+ * Initializes the local property mapper.
+ *
+ * Provide an implementation for each application domain type.
+ */
+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<PropertyMapper<ResourceBuffer> > mResourceMapper;
+    QSharedPointer<ReadPropertyMapper<LocalBuffer> > mLocalMapper;
+    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);
-    auto resource = fbb.CreateVector<uint8_t>(static_cast<uint8_t const*>(resourceData), resourceSize);
-    auto local = fbb.CreateVector<uint8_t>(static_cast<uint8_t const*>(localData), localSize);
-    auto builder = Akonadi2::EntityBuilder(fbb);
-    builder.add_metadata(metadata);
-    builder.add_resource(resource);
-    builder.add_local(local);
+    //Since we do memcpy trickery, this will only work on little endian
+    assert(FLATBUFFERS_LITTLEENDIAN);
+    auto metadata = fbb.CreateUninitializedVector<uint8_t>(size);
+    {
+        auto ptr = reinterpret_cast<flatbuffers::Vector<uint8_t> *>(fbb.GetBufferPointer())->Data();
+        std::memcpy((void*)ptr, data, size);
+    }
+    return metadata;
+}
 
-    auto buffer = builder.Finish();
-    Akonadi2::FinishEntityBuffer(fbb, buffer);
+void EntityBuffer::assembleEntityBuffer(flatbuffers::FlatBufferBuilder &fbb, void const *metadataData, size_t metadataSize, void const *resourceData, size_t resourceSize, void const *localData, size_t localSize)
+{
+    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);
-    QString resourceName;
+    Private(const QByteArray &name, ResourceAccess *ra);
+    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> modify(const Akonadi2::Domain::Event &domainObject){ return Async::null<void>(); };
-    virtual Async::Job<void> remove(const Akonadi2::Domain::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> create(const Akonadi2::ApplicationDomain::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::ApplicationDomain::Event &domainObject){ return Async::null<void>(); };
+    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);
     }