Moved default read/write property mapper to TypeImplementation

There is always exactly one default buffer that we can centralize
in TypeImplementation.

11 files changed, 193 insertions, 119 deletions

diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 6a048ea..9e30752 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -17,6 +17,7 @@ set(command_SRCS
     commands.cpp
     facade.cpp
     pipeline.cpp
+    propertymapper.cpp
     domainadaptor.cpp
     resource.cpp
     genericresource.cpp
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index 2de1460..f2a4ad6 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -130,5 +130,14 @@ QByteArray getTypeName<Todo>();
 template<>
 QByteArray getTypeName<AkonadiResource>();
 
+/**
+ * Type implementation.
+ * 
+ * Needs to be implemented for every application domain type.
+ * Contains all non-resource specific, but type-specific code.
+ */
+template<typename DomainType>
+class TypeImplementation;
+
 }
 }
diff --git a/common/domain/event.cpp b/common/domain/event.cpp
index 86100b7..ea0931c 100644
--- a/common/domain/event.cpp
+++ b/common/domain/event.cpp
@@ -20,15 +20,19 @@
 
 #include <QVector>
 #include <QByteArray>
+#include <QString>
 
 #include "../resultset.h"
 #include "../index.h"
 #include "../storage.h"
 #include "../log.h"
+#include "../propertymapper.h"
+
+#include "event_generated.h"
 
 using namespace Akonadi2::ApplicationDomain;
 
-ResultSet EventImplementation::queryIndexes(const Akonadi2::Query &query, const QByteArray &resourceInstanceIdentifier)
+ResultSet TypeImplementation<Event>::queryIndexes(const Akonadi2::Query &query, const QByteArray &resourceInstanceIdentifier)
 {
     QVector<QByteArray> keys;
     if (query.propertyFilter.contains("uid")) {
@@ -43,7 +47,7 @@ ResultSet EventImplementation::queryIndexes(const Akonadi2::Query &query, const
     return ResultSet(keys);
 }
 
-void EventImplementation::index(const Event &type)
+void TypeImplementation<Event>::index(const Event &type)
 {
     Index uidIndex(Akonadi2::Store::storageLocation(), type.resourceInstanceIdentifier() + "index.uid", Akonadi2::Storage::ReadWrite);
     const auto uid = type.getProperty("uid");
@@ -51,3 +55,29 @@ void EventImplementation::index(const Event &type)
         uidIndex.add(uid.toByteArray(), type.identifier());
     }
 }
+
+QSharedPointer<ReadPropertyMapper<Buffer::Event> > TypeImplementation<Event>::initializeReadPropertyMapper()
+{
+    auto propertyMapper = QSharedPointer<ReadPropertyMapper<Buffer::Event> >::create();
+    propertyMapper->addMapping("summary", [](Buffer::Event const *buffer) -> QVariant {
+        return propertyToVariant<QString>(buffer->summary());
+    });
+    propertyMapper->addMapping("uid", [](Buffer::Event const *buffer) -> QVariant {
+        return propertyToVariant<QString>(buffer->uid());
+    });
+    return propertyMapper;
+}
+
+QSharedPointer<WritePropertyMapper<Buffer::EventBuilder> > TypeImplementation<Event>::initializeWritePropertyMapper()
+{
+    auto propertyMapper = QSharedPointer<WritePropertyMapper<Buffer::EventBuilder> >::create();
+    propertyMapper->addMapping("summary", [](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(Buffer::EventBuilder &)> {
+        auto offset = variantToProperty<QString>(value, fbb);
+        return [offset](Buffer::EventBuilder &builder) { builder.add_summary(offset); };
+    });
+    propertyMapper->addMapping("uid", [](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(Buffer::EventBuilder &)> {
+        auto offset = variantToProperty<QString>(value, fbb);
+        return [offset](Buffer::EventBuilder &builder) { builder.add_uid(offset); };
+    });
+    return propertyMapper;
+}
diff --git a/common/domain/event.h b/common/domain/event.h
index 4cb0d34..d4ce20e 100644
--- a/common/domain/event.h
+++ b/common/domain/event.h
@@ -23,23 +23,34 @@
 class ResultSet;
 class QByteArray;
 
+template<typename T>
+class ReadPropertyMapper;
+template<typename T>
+class WritePropertyMapper;
+
 namespace Akonadi2 {
     class Query;
 
 namespace ApplicationDomain {
+    namespace Buffer {
+        class Event;
+        class EventBuilder;
+    }
 
 /**
  * Implements all type-specific code such as updating and querying indexes.
  */
-namespace EventImplementation {
-    typedef Event DomainType;
+template<>
+struct TypeImplementation<Akonadi2::ApplicationDomain::Event> {
     /**
      * Returns the potential result set based on the indexes.
      * 
      * An empty result set indicates that a full scan is required.
      */
-    ResultSet queryIndexes(const Akonadi2::Query &query, const QByteArray &resourceInstanceIdentifier);
-    void index(const Event &type);
+    static ResultSet queryIndexes(const Akonadi2::Query &query, const QByteArray &resourceInstanceIdentifier);
+    static void index(const Event &type);
+    static QSharedPointer<ReadPropertyMapper<Akonadi2::ApplicationDomain::Buffer::Event> > initializeReadPropertyMapper();
+    static QSharedPointer<WritePropertyMapper<Akonadi2::ApplicationDomain::Buffer::EventBuilder> > initializeWritePropertyMapper();
 };
 
 }
diff --git a/common/domainadaptor.cpp b/common/domainadaptor.cpp
index 8a4b5ed..2955cab 100644
--- a/common/domainadaptor.cpp
+++ b/common/domainadaptor.cpp
@@ -19,48 +19,3 @@
 
 #include "domainadaptor.h"
 
-template <>
-flatbuffers::uoffset_t variantToProperty<QString>(const QVariant &property, flatbuffers::FlatBufferBuilder &fbb)
-{
-    if (property.isValid()) {
-        return fbb.CreateString(property.toString().toStdString()).o;
-    }
-    return 0;
-}
-
-template <>
-QVariant propertyToVariant<QString>(const flatbuffers::String *property)
-{
-    if (property) {
-        return QString::fromStdString(property->c_str());
-    }
-    return QVariant();
-}
-
-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 {
-        return propertyToVariant<QString>(buffer->summary());
-    });
-    propertyMapper->addMapping("uid", [](Akonadi2::ApplicationDomain::Buffer::Event const *buffer) -> QVariant {
-        return propertyToVariant<QString>(buffer->uid());
-    });
-    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 = variantToProperty<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 = variantToProperty<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 fd015b5..70c3a42 100644
--- a/common/domainadaptor.h
+++ b/common/domainadaptor.h
@@ -29,65 +29,8 @@
 #include "entity_generated.h"
 #include "metadata_generated.h"
 #include "entitybuffer.h"
-
-/**
- * The property mapper is a non-typesafe virtual dispatch.
- *
- * 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 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:
-    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);
-            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
- */
-template <class T>
-flatbuffers::uoffset_t variantToProperty(const QVariant &, flatbuffers::FlatBufferBuilder &fbb);
-
-/**
- * Defines how to convert flatbuffer primitives to qt ones
- */
-template <typename T>
-QVariant propertyToVariant(const flatbuffers::String *);
+#include "propertymapper.h"
+#include "domain/event.h"
 
 /**
  * Create a buffer from a domain object using the provided mappings
@@ -177,7 +120,7 @@ class DomainTypeAdaptorFactoryInterface
 public:
     virtual ~DomainTypeAdaptorFactoryInterface() {};
     virtual QSharedPointer<Akonadi2::ApplicationDomain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity) = 0;
-    virtual void createBuffer(const DomainType &event, flatbuffers::FlatBufferBuilder &fbb) = 0;
+    virtual void createBuffer(const DomainType &domainType, flatbuffers::FlatBufferBuilder &fbb) = 0;
 };
 
 /**
@@ -190,9 +133,9 @@ class DomainTypeAdaptorFactory : public DomainTypeAdaptorFactoryInterface<Domain
 {
 public:
     DomainTypeAdaptorFactory() :
-        mLocalMapper(initializeReadPropertyMapper<LocalBuffer>()),
+        mLocalMapper(Akonadi2::ApplicationDomain::TypeImplementation<DomainType>::initializeReadPropertyMapper()),
         mResourceMapper(QSharedPointer<ReadPropertyMapper<ResourceBuffer> >::create()),
-        mLocalWriteMapper(initializeWritePropertyMapper<LocalBuilder>()),
+        mLocalWriteMapper(Akonadi2::ApplicationDomain::TypeImplementation<DomainType>::initializeWritePropertyMapper()),
         mResourceWriteMapper(QSharedPointer<WritePropertyMapper<ResourceBuilder> >::create())
     {};
     virtual ~DomainTypeAdaptorFactory() {};
@@ -216,7 +159,7 @@ public:
         return adaptor;
     }
 
-    virtual void createBuffer(const Akonadi2::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb) Q_DECL_OVERRIDE {};
+    virtual void createBuffer(const DomainType &domainType, flatbuffers::FlatBufferBuilder &fbb) Q_DECL_OVERRIDE {};
 
 protected:
     QSharedPointer<ReadPropertyMapper<LocalBuffer> > mLocalMapper;
diff --git a/common/propertymapper.cpp b/common/propertymapper.cpp
new file mode 100644
index 0000000..0896aa6
--- /dev/null
+++ b/common/propertymapper.cpp
@@ -0,0 +1,39 @@
+/*
+ * 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 "propertymapper.h"
+
+template <>
+flatbuffers::uoffset_t variantToProperty<QString>(const QVariant &property, flatbuffers::FlatBufferBuilder &fbb)
+{
+    if (property.isValid()) {
+        return fbb.CreateString(property.toString().toStdString()).o;
+    }
+    return 0;
+}
+
+template <>
+QVariant propertyToVariant<QString>(const flatbuffers::String *property)
+{
+    if (property) {
+        return QString::fromStdString(property->c_str());
+    }
+    return QVariant();
+}
+
diff --git a/common/propertymapper.h b/common/propertymapper.h
new file mode 100644
index 0000000..0c6c16f
--- /dev/null
+++ b/common/propertymapper.h
@@ -0,0 +1,86 @@
+/*
+ * 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 <QVariant>
+#include <QByteArray>
+#include <functional>
+#include <flatbuffers/flatbuffers.h>
+
+/**
+ * Defines how to convert qt primitives to flatbuffer ones
+ */
+template <class T>
+flatbuffers::uoffset_t variantToProperty(const QVariant &, flatbuffers::FlatBufferBuilder &fbb);
+
+/**
+ * Defines how to convert flatbuffer primitives to qt ones
+ */
+template <typename T>
+QVariant propertyToVariant(const flatbuffers::String *);
+
+
+/**
+ * The property mapper is a non-typesafe virtual dispatch.
+ *
+ * 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 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:
+    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);
+            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;
+};
+
diff --git a/examples/dummyresource/facade.cpp b/examples/dummyresource/facade.cpp
index 611217f..e678214 100644
--- a/examples/dummyresource/facade.cpp
+++ b/examples/dummyresource/facade.cpp
@@ -130,11 +130,11 @@ void DummyResourceFacade::readValue(const QSharedPointer<Akonadi2::Storage> &sto
 
 static ResultSet getResultSet(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::Storage> &storage)
 {
-    auto resultSet = Akonadi2::ApplicationDomain::EventImplementation::queryIndexes(query, "org.kde.dummy");
+    auto resultSet = Akonadi2::ApplicationDomain::TypeImplementation<Akonadi2::ApplicationDomain::Event>::queryIndexes(query, "org.kde.dummy");
 
     //Scan for where we don't have an index
     //TODO: we may want a way for queryIndexes to indicate that the resultSet is not final, and that a scan over the remaining set is required
-    //TODO: the prepared query should be generalized in EventImplementation on top of domain adaptors
+    //TODO: the prepared query should be generalized in TypeImplementation on top of domain adaptors
     if (resultSet.isEmpty()) {
         QVector<QByteArray> keys;
         const auto preparedQuery = prepareQuery(query);
diff --git a/examples/dummyresource/resourcefactory.cpp b/examples/dummyresource/resourcefactory.cpp
index 71a4ac5..31ec972 100644
--- a/examples/dummyresource/resourcefactory.cpp
+++ b/examples/dummyresource/resourcefactory.cpp
@@ -122,7 +122,7 @@ void DummyResource::configurePipeline(Akonadi2::Pipeline *pipeline)
         auto adaptor = eventFactory->createAdaptor(entity);
         //FIXME set revision?
         Akonadi2::ApplicationDomain::Event event(resourceIdentifier, state.key(), -1, adaptor);
-        Akonadi2::ApplicationDomain::EventImplementation::index(event);
+        Akonadi2::ApplicationDomain::TypeImplementation<Akonadi2::ApplicationDomain::Event>::index(event);
     });
 
     //event is the entitytype and not the domain type
diff --git a/tests/domainadaptortest.cpp b/tests/domainadaptortest.cpp
index 1e285dc..97a78c2 100644
--- a/tests/domainadaptortest.cpp
+++ b/tests/domainadaptortest.cpp
@@ -18,7 +18,7 @@ class TestFactory : public DomainTypeAdaptorFactory<Akonadi2::ApplicationDomain:
 public:
     TestFactory()
     {
-        mResourceWriteMapper = initializeWritePropertyMapper<Akonadi2::ApplicationDomain::Buffer::EventBuilder>();
+        mResourceWriteMapper = Akonadi2::ApplicationDomain::TypeImplementation<Akonadi2::ApplicationDomain::Event>::initializeWritePropertyMapper();
     }
 };
 
@@ -36,7 +36,7 @@ private Q_SLOTS:
 
     void testCreateBufferPart()
     {
-        auto writeMapper = initializeWritePropertyMapper<Akonadi2::ApplicationDomain::Buffer::EventBuilder>();
+        auto writeMapper = Akonadi2::ApplicationDomain::TypeImplementation<Akonadi2::ApplicationDomain::Event>::initializeWritePropertyMapper();
 
         Akonadi2::ApplicationDomain::Event event;
         event.setProperty("summary", "foo");