14 files changed, 102 insertions, 104 deletions

diff --git a/common/clientapi.cpp b/common/clientapi.cpp
index 0281b79..48de1b0 100644
--- a/common/clientapi.cpp
+++ b/common/clientapi.cpp
@@ -14,7 +14,7 @@ namespace async
 namespace Akonadi2
 {
 
-namespace Domain
+namespace ApplicationDomain
 {
 
 template<>
diff --git a/common/clientapi.h b/common/clientapi.h
index 37fb185..5182547 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
@@ -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 QByteArray &resourceName, const QByteArray &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,7 +230,7 @@ public:
     {
     }
 
-    virtual ~AkonadiDomainType() {}
+    virtual ~ApplicationDomainType() {}
 
     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); }
@@ -246,25 +246,25 @@ private:
     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 {
 };
 
 /**
@@ -331,7 +331,7 @@ template<class DomainType>
 class StoreFacade {
 public:
     virtual ~StoreFacade(){};
-    QByteArray 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;
@@ -362,7 +362,7 @@ public:
     template<class DomainType, class Facade>
     void registerFacade(const QByteArray &resource)
     {
-        const QByteArray typeName = Domain::getTypeName<DomainType>();
+        const QByteArray typeName = ApplicationDomain::getTypeName<DomainType>();
         mFacadeRegistry.insert(key(resource, typeName), [](){ return new Facade; });
     }
 
@@ -378,14 +378,14 @@ public:
     template<class DomainType, class Facade>
     void registerFacade(const QByteArray &resource, const std::function<void*(void)> &customFactoryFunction)
     {
-        const QByteArray typeName = Domain::getTypeName<DomainType>();
+        const QByteArray typeName = ApplicationDomain::getTypeName<DomainType>();
         mFacadeRegistry.insert(key(resource, typeName), customFactoryFunction);
     }
 
     template<class DomainType>
     QSharedPointer<StoreFacade<DomainType> > getFacade(const QByteArray &resource)
     {
-        const QByteArray 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()));
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.h b/common/domainadaptor.h
index 692c8c1..df3f8e5 100644
--- a/common/domainadaptor.h
+++ b/common/domainadaptor.h
@@ -68,8 +68,8 @@ class DomainTypeAdaptorFactory/* <typename DomainType, LocalBuffer, ResourceBuff
 {
 public:
     virtual ~DomainTypeAdaptorFactory() {};
-    virtual QSharedPointer<Akonadi2::Domain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity) = 0;
-    virtual void createBuffer(const Akonadi2::Domain::Event &event, flatbuffers::FlatBufferBuilder &fbb) {};
+    virtual QSharedPointer<Akonadi2::ApplicationDomain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity) = 0;
+    virtual void createBuffer(const Akonadi2::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb) {};
 
 protected:
     QSharedPointer<PropertyMapper<LocalBuffer> > mLocalMapper;
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);
     }
diff --git a/dummyresource/domainadaptor.cpp b/dummyresource/domainadaptor.cpp
index 865a4c0..b133614 100644
--- a/dummyresource/domainadaptor.cpp
+++ b/dummyresource/domainadaptor.cpp
@@ -14,11 +14,8 @@
 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
+class DummyEventAdaptor : public Akonadi2::ApplicationDomain::BufferAdaptor
 {
 public:
     DummyEventAdaptor()
@@ -55,10 +52,10 @@ public:
         return props;
     }
 
-    Akonadi2::Domain::Buffer::Event const *mLocalBuffer;
+    Akonadi2::ApplicationDomain::Buffer::Event const *mLocalBuffer;
     DummyEvent const *mResourceBuffer;
 
-    QSharedPointer<PropertyMapper<Akonadi2::Domain::Buffer::Event> > mLocalMapper;
+    QSharedPointer<PropertyMapper<Akonadi2::ApplicationDomain::Buffer::Event> > mLocalMapper;
     QSharedPointer<PropertyMapper<DummyEvent> > mResourceMapper;
 };
 
@@ -73,14 +70,14 @@ DummyEventAdaptorFactory::DummyEventAdaptorFactory()
         }
         return QVariant();
     });
-    mLocalMapper = QSharedPointer<PropertyMapper<Akonadi2::Domain::Buffer::Event> >::create();
-    mLocalMapper->mReadAccessors.insert("summary", [](Akonadi2::Domain::Buffer::Event const *buffer) -> QVariant {
+    mLocalMapper = QSharedPointer<PropertyMapper<Akonadi2::ApplicationDomain::Buffer::Event> >::create();
+    mLocalMapper->mReadAccessors.insert("summary", [](Akonadi2::ApplicationDomain::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 {
+    mLocalMapper->mReadAccessors.insert("uid", [](Akonadi2::ApplicationDomain::Buffer::Event const *buffer) -> QVariant {
         if (buffer->uid()) {
             return QString::fromStdString(buffer->uid()->c_str());
         }
@@ -90,10 +87,10 @@ DummyEventAdaptorFactory::DummyEventAdaptorFactory()
 }
 
 //TODO pass EntityBuffer instead?
-QSharedPointer<Akonadi2::Domain::BufferAdaptor> DummyEventAdaptorFactory::createAdaptor(const Akonadi2::Entity &entity)
+QSharedPointer<Akonadi2::ApplicationDomain::BufferAdaptor> DummyEventAdaptorFactory::createAdaptor(const Akonadi2::Entity &entity)
 {
     const auto resourceBuffer = Akonadi2::EntityBuffer::readBuffer<DummyEvent>(entity.resource());
-    const auto localBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Domain::Buffer::Event>(entity.local());
+    const auto localBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::ApplicationDomain::Buffer::Event>(entity.local());
     // const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(entity.metadata());
 
     auto adaptor = QSharedPointer<DummyEventAdaptor>::create();
@@ -104,7 +101,7 @@ QSharedPointer<Akonadi2::Domain::BufferAdaptor> DummyEventAdaptorFactory::create
     return adaptor;
 }
 
-void DummyEventAdaptorFactory::createBuffer(const Akonadi2::Domain::Event &event, flatbuffers::FlatBufferBuilder &fbb)
+void DummyEventAdaptorFactory::createBuffer(const Akonadi2::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb)
 {
     flatbuffers::FlatBufferBuilder eventFbb;
     eventFbb.Clear();
@@ -119,10 +116,10 @@ void DummyEventAdaptorFactory::createBuffer(const Akonadi2::Domain::Event &event
     flatbuffers::FlatBufferBuilder localFbb;
     {
         auto uid = localFbb.CreateString(event.getProperty("uid").toString().toStdString());
-        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);
     }
 
     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 a2fb8a9..143121a 100644
--- a/dummyresource/domainadaptor.h
+++ b/dummyresource/domainadaptor.h
@@ -5,11 +5,11 @@
 #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>
 {
 public:
     DummyEventAdaptorFactory();
     virtual ~DummyEventAdaptorFactory() {};
-    virtual QSharedPointer<Akonadi2::Domain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity);
-    virtual void createBuffer(const Akonadi2::Domain::Event &event, flatbuffers::FlatBufferBuilder &fbb);
+    virtual QSharedPointer<Akonadi2::ApplicationDomain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity);
+    virtual void createBuffer(const Akonadi2::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb);
 };
diff --git a/dummyresource/facade.cpp b/dummyresource/facade.cpp
index 7c64675..980833f 100644
--- a/dummyresource/facade.cpp
+++ b/dummyresource/facade.cpp
@@ -38,7 +38,7 @@ using namespace flatbuffers;
 
 
 DummyResourceFacade::DummyResourceFacade()
-    : Akonadi2::GenericFacade<Akonadi2::Domain::Event>("org.kde.dummy"),
+    : Akonadi2::GenericFacade<Akonadi2::ApplicationDomain::Event>("org.kde.dummy"),
     mFactory(new DummyEventAdaptorFactory)
 {
 }
@@ -47,30 +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()));
 }
 
-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
@@ -81,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;
             }
@@ -90,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;
                 }
@@ -99,14 +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;
 }
 
-void DummyResourceFacade::readValue(QSharedPointer<Akonadi2::Storage> storage, const QByteArray &key, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback, std::function<bool(const std::string &key, DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local)> preparedQuery)
+void DummyResourceFacade::readValue(QSharedPointer<Akonadi2::Storage> storage, const QByteArray &key, const std::function<void(const Akonadi2::ApplicationDomain::Event::Ptr &)> &resultCallback, std::function<bool(const std::string &key, DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local)> preparedQuery)
 {
     storage->scan(key, [=](void *keyValue, int keySize, void *dataValue, int dataSize) -> bool {
 
@@ -119,7 +119,7 @@ void DummyResourceFacade::readValue(QSharedPointer<Akonadi2::Storage> storage, c
         Akonadi2::EntityBuffer buffer(dataValue, dataSize);
 
         const auto resourceBuffer = Akonadi2::EntityBuffer::readBuffer<DummyEvent>(buffer.entity().resource());
-        const auto localBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Domain::Buffer::Event>(buffer.entity().local());
+        const auto localBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::ApplicationDomain::Buffer::Event>(buffer.entity().local());
         const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(buffer.entity().metadata());
 
         if (!resourceBuffer || !metadataBuffer) {
@@ -135,8 +135,8 @@ void DummyResourceFacade::readValue(QSharedPointer<Akonadi2::Storage> storage, c
             //Not i.e. for tags that are stored as flags in each entity of an imap store.
             auto adaptor = mFactory->createAdaptor(buffer.entity());
             //TODO only copy requested properties
-            auto memoryAdaptor = QSharedPointer<Akonadi2::Domain::MemoryBufferAdaptor>::create(*adaptor);
-            auto event = QSharedPointer<Akonadi2::Domain::Event>::create("org.kde.dummy", QByteArray::fromRawData(static_cast<char*>(keyValue), keySize), revision, memoryAdaptor);
+            auto memoryAdaptor = QSharedPointer<Akonadi2::ApplicationDomain::MemoryBufferAdaptor>::create(*adaptor);
+            auto event = QSharedPointer<Akonadi2::ApplicationDomain::Event>::create("org.kde.dummy", QByteArray::fromRawData(static_cast<char*>(keyValue), keySize), revision, memoryAdaptor);
             resultCallback(event);
         }
         return true;
@@ -146,7 +146,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
@@ -154,6 +154,7 @@ Async::Job<void> DummyResourceFacade::load(const Akonadi2::Query &query, const s
 
         auto storage = QSharedPointer<Akonadi2::Storage>::create(Akonadi2::Store::storageLocation(), "org.kde.dummy");
 
+        //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 195c50f..7bef2cc 100644
--- a/dummyresource/facade.h
+++ b/dummyresource/facade.h
@@ -29,17 +29,17 @@
 #include "dummycalendar_generated.h"
 #include "common/domainadaptor.h"
 
-class DummyResourceFacade : public Akonadi2::GenericFacade<Akonadi2::Domain::Event>
+class DummyResourceFacade : public Akonadi2::GenericFacade<Akonadi2::ApplicationDomain::Event>
 {
 public:
     DummyResourceFacade();
     virtual ~DummyResourceFacade();
-    virtual Async::Job<void> create(const Akonadi2::Domain::Event &domainObject);
-    virtual Async::Job<void> modify(const Akonadi2::Domain::Event &domainObject);
-    virtual Async::Job<void> remove(const Akonadi2::Domain::Event &domainObject);
-    virtual Async::Job<void> load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback);
+    virtual Async::Job<void> create(const Akonadi2::ApplicationDomain::Event &domainObject);
+    virtual Async::Job<void> modify(const Akonadi2::ApplicationDomain::Event &domainObject);
+    virtual Async::Job<void> remove(const Akonadi2::ApplicationDomain::Event &domainObject);
+    virtual Async::Job<void> load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::ApplicationDomain::Event::Ptr &)> &resultCallback);
 
 private:
-    void readValue(QSharedPointer<Akonadi2::Storage> storage, const QByteArray &key, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback, std::function<bool(const std::string &key, DummyCalendar::DummyEvent const *buffer, Akonadi2::Domain::Buffer::Event const *local)>);
-    QSharedPointer<DomainTypeAdaptorFactory<Akonadi2::Domain::Event, Akonadi2::Domain::Buffer::Event, DummyCalendar::DummyEvent> > mFactory;
+    void readValue(QSharedPointer<Akonadi2::Storage> storage, const QByteArray &key, const std::function<void(const Akonadi2::ApplicationDomain::Event::Ptr &)> &resultCallback, std::function<bool(const std::string &key, DummyCalendar::DummyEvent const *buffer, Akonadi2::ApplicationDomain::Buffer::Event const *local)>);
+    QSharedPointer<DomainTypeAdaptorFactory<Akonadi2::ApplicationDomain::Event, Akonadi2::ApplicationDomain::Buffer::Event, DummyCalendar::DummyEvent> > mFactory;
 };
diff --git a/dummyresource/resourcefactory.cpp b/dummyresource/resourcefactory.cpp
index ea37466..04413c2 100644
--- a/dummyresource/resourcefactory.cpp
+++ b/dummyresource/resourcefactory.cpp
@@ -416,7 +416,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 00d9207..7481537 100644
--- a/synchronizer/listener.cpp
+++ b/synchronizer/listener.cpp
@@ -365,7 +365,7 @@ 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() << "\tFacades: " << 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() << "Failed to load resource " << m_resourceName;
diff --git a/tests/domainadaptortest.cpp b/tests/domainadaptortest.cpp
index e45a9a3..9cc3938 100644
--- a/tests/domainadaptortest.cpp
+++ b/tests/domainadaptortest.cpp
@@ -13,11 +13,11 @@
 #include "metadata_generated.h"
 #include "entity_generated.h"
 
-class TestEventAdaptor : public Akonadi2::Domain::BufferAdaptor
+class TestEventAdaptor : public Akonadi2::ApplicationDomain::BufferAdaptor
 {
 public:
     TestEventAdaptor()
-        : Akonadi2::Domain::BufferAdaptor()
+        : Akonadi2::ApplicationDomain::BufferAdaptor()
     {
     }
 
@@ -40,20 +40,20 @@ public:
         return QVariant();
     }
 
-    Akonadi2::Domain::Buffer::Event const *mLocalBuffer;
-    Akonadi2::Domain::Buffer::Event const *mResourceBuffer;
+    Akonadi2::ApplicationDomain::Buffer::Event const *mLocalBuffer;
+    Akonadi2::ApplicationDomain::Buffer::Event const *mResourceBuffer;
 
-    QSharedPointer<PropertyMapper<Akonadi2::Domain::Buffer::Event> > mLocalMapper;
-    QSharedPointer<PropertyMapper<Akonadi2::Domain::Buffer::Event> > mResourceMapper;
+    QSharedPointer<PropertyMapper<Akonadi2::ApplicationDomain::Buffer::Event> > mLocalMapper;
+    QSharedPointer<PropertyMapper<Akonadi2::ApplicationDomain::Buffer::Event> > mResourceMapper;
 };
 
-class TestFactory : public DomainTypeAdaptorFactory<Akonadi2::Domain::Event, Akonadi2::Domain::Buffer::Event, Akonadi2::Domain::Buffer::Event>
+class TestFactory : public DomainTypeAdaptorFactory<Akonadi2::ApplicationDomain::Event, Akonadi2::ApplicationDomain::Buffer::Event, Akonadi2::ApplicationDomain::Buffer::Event>
 {
 public:
     TestFactory()
     {
-        mResourceMapper = QSharedPointer<PropertyMapper<Akonadi2::Domain::Buffer::Event> >::create();
-        mResourceMapper->mReadAccessors.insert("summary", [](Akonadi2::Domain::Buffer::Event const *buffer) -> QVariant {
+        mResourceMapper = QSharedPointer<PropertyMapper<Akonadi2::ApplicationDomain::Buffer::Event> >::create();
+        mResourceMapper->mReadAccessors.insert("summary", [](Akonadi2::ApplicationDomain::Buffer::Event const *buffer) -> QVariant {
             if (buffer->summary()) {
                 return QString::fromStdString(buffer->summary()->c_str());
             }
@@ -61,13 +61,13 @@ public:
         });
     }
 
-    virtual QSharedPointer<Akonadi2::Domain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity)
+    virtual QSharedPointer<Akonadi2::ApplicationDomain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity)
     {
-        Akonadi2::Domain::Buffer::Event const *resourceBuffer = 0;
+        Akonadi2::ApplicationDomain::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 (Akonadi2::ApplicationDomain::Buffer::VerifyEventBuffer(verifyer)) {
+                resourceBuffer = Akonadi2::ApplicationDomain::Buffer::GetEvent(resourceData->Data());
                 if (resourceBuffer->summary()) {
                     qDebug() << QString::fromStdString(std::string(resourceBuffer->summary()->c_str()));
                 }
@@ -82,11 +82,11 @@ public:
         //     }
         // }
 
-        Akonadi2::Domain::Buffer::Event const *localBuffer = 0;
+        Akonadi2::ApplicationDomain::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);
+            if (Akonadi2::ApplicationDomain::Buffer::VerifyEventBuffer(verifyer)) {
+                localBuffer = Akonadi2::ApplicationDomain::Buffer::GetEvent(localData);
             }
         }
 
@@ -127,12 +127,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 308a4e8..ea3f556 100644
--- a/tests/dummyresourcebenchmark.cpp
+++ b/tests/dummyresourcebenchmark.cpp
@@ -47,11 +47,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();
 
@@ -63,7 +63,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();
@@ -77,7 +77,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);
         }
@@ -146,7 +146,7 @@ private Q_SLOTS:
     }
     void testCreateCommand()
     {
-        Akonadi2::Domain::Event event;
+        Akonadi2::ApplicationDomain::Event event;
 
         QBENCHMARK {
             auto mFactory = new DummyEventAdaptorFactory;
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();