From 9e002cca99ad176fd9168123955cc0779a4e1237 Mon Sep 17 00:00:00 2001
From: Christian Mollekopf <chrigi_1@fastmail.fm>
Date: Tue, 10 May 2016 14:26:33 +0200
Subject: Property definitions

Instead of hardcoding assumptions all over the place we create typesafe
setters and getters for all properties.
---
 common/domain/applicationdomaintype.h | 94 ++++++++++++++++++++++++++++-------
 common/domain/event.cpp               | 16 +++---
 common/domain/folder.cpp              | 16 +++---
 common/domain/mail.cpp                | 41 +++++++--------
 common/propertymapper.h               | 50 +++++++++----------
 5 files changed, 138 insertions(+), 79 deletions(-)

(limited to 'common')

diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index eadad00..4eec4a3 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -23,12 +23,56 @@
 #include <QSharedPointer>
 #include <QVariant>
 #include <QByteArray>
+#include <QDateTime>
 #include <QDebug>
 #include <QUuid>
 #include "bufferadaptor.h"
 
-namespace Sink {
+#define SINK_ENTITY(TYPE) \
+    typedef QSharedPointer<TYPE> Ptr; \
+    using Entity::Entity; \
+    virtual ~TYPE(); \
+
+
+#define SINK_PROPERTY(TYPE, NAME, LOWERCASENAME) \
+    struct NAME { \
+        static constexpr const char *name = #LOWERCASENAME; \
+        typedef TYPE Type; \
+    }; \
+    void set##NAME(const TYPE &value) { setProperty(NAME::name, QVariant::fromValue(value)); } \
+    TYPE get##NAME() const { return getProperty(NAME::name).value<TYPE>(); } \
+
+
+#define SINK_EXTRACTED_PROPERTY(TYPE, NAME, LOWERCASENAME) \
+    struct NAME { \
+        static constexpr const char *name = #LOWERCASENAME; \
+        typedef TYPE Type; \
+    }; \
+    void setExtracted##NAME(const TYPE &value) { setProperty(NAME::name, QVariant::fromValue(value)); } \
+    TYPE get##NAME() const { return getProperty(NAME::name).value<TYPE>(); } \
+
+
+#define SINK_BLOB_PROPERTY(NAME, LOWERCASENAME) \
+    struct NAME { \
+        static constexpr const char *name = #LOWERCASENAME; \
+        typedef QString Type; \
+    }; \
+    void set##NAME(const QByteArray &value) { setBlobProperty(NAME::name, value); } \
+    void set##NAME##Path(const QString &path) { setProperty(NAME::name, QVariant::fromValue(path)); } \
+    QByteArray get##NAME() const { return getBlobProperty(NAME::name); } \
+    QString get##NAME##Path() const { return getProperty(NAME::name).value<QString>(); } \
+
+#define SINK_REFERENCE_PROPERTY(TYPE, NAME, LOWERCASENAME) \
+    struct NAME { \
+        static constexpr const char *name = #LOWERCASENAME; \
+        typedef QByteArray Type; \
+    }; \
+    void set##NAME(const ApplicationDomain::TYPE &value) { setProperty(NAME::name, value); } \
+    void set##NAME(const QByteArray &value) { setProperty(NAME::name, QVariant::fromValue(value)); } \
+    QByteArray get##NAME() const { return getProperty(NAME::name).value<QByteArray>(); } \
+
 
+namespace Sink {
 namespace ApplicationDomain {
 
 /**
@@ -128,33 +172,41 @@ struct SINK_EXPORT Entity : public ApplicationDomainType {
 };
 
 struct SINK_EXPORT Event : public Entity {
-    typedef QSharedPointer<Event> Ptr;
-    using Entity::Entity;
-    virtual ~Event();
+    SINK_ENTITY(Event);
+    SINK_PROPERTY(QString, Uid, uid);
+    SINK_PROPERTY(QString, Summary, summary);
+    SINK_PROPERTY(QString, Description, description);
+    SINK_PROPERTY(QByteArray, Attachment, attachment);
 };
 
 struct SINK_EXPORT Todo : public Entity {
-    typedef QSharedPointer<Todo> Ptr;
-    using Entity::Entity;
-    virtual ~Todo();
+    SINK_ENTITY(Todo);
 };
 
 struct SINK_EXPORT Calendar : public Entity {
-    typedef QSharedPointer<Calendar> Ptr;
-    using Entity::Entity;
-    virtual ~Calendar();
+    SINK_ENTITY(Calendar);
 };
 
-struct SINK_EXPORT Mail : public Entity {
-    typedef QSharedPointer<Mail> Ptr;
-    using Entity::Entity;
-    virtual ~Mail();
+struct SINK_EXPORT Folder : public Entity {
+    SINK_ENTITY(Folder);
+    SINK_REFERENCE_PROPERTY(Folder, Parent, parent);
+    SINK_PROPERTY(QString, Name, name);
+    SINK_PROPERTY(QByteArray, Icon, icon);
+    SINK_PROPERTY(QByteArrayList, SpecialPurpose, specialpurpose);
 };
 
-struct SINK_EXPORT Folder : public Entity {
-    typedef QSharedPointer<Folder> Ptr;
-    using Entity::Entity;
-    virtual ~Folder();
+struct SINK_EXPORT Mail : public Entity {
+    SINK_ENTITY(Mail);
+    SINK_PROPERTY(QString, Uid, uid);
+    SINK_EXTRACTED_PROPERTY(QString, Sender, sender);
+    SINK_EXTRACTED_PROPERTY(QString, SenderName, senderName);
+    SINK_EXTRACTED_PROPERTY(QString, Subject, subject);
+    SINK_EXTRACTED_PROPERTY(QDateTime, Date, date);
+    SINK_PROPERTY(bool, Unread, unread);
+    SINK_PROPERTY(bool, Important, important);
+    SINK_REFERENCE_PROPERTY(Folder, Folder, folder);
+    SINK_BLOB_PROPERTY(MimeMessage, mimeMessage);
+    SINK_PROPERTY(bool, Draft, draft);
 };
 
 /**
@@ -235,6 +287,12 @@ class SINK_EXPORT TypeImplementation;
 }
 }
 
+#undef SINK_ENTITY
+#undef SINK_PROPERTY
+#undef SINK_EXTRACTED_PROPERTY
+#undef SINK_BLOB_PROPERTY
+#undef SINK_REFERENCE_PROPERTY
+
 Q_DECLARE_METATYPE(Sink::ApplicationDomain::ApplicationDomainType)
 Q_DECLARE_METATYPE(Sink::ApplicationDomain::ApplicationDomainType::Ptr)
 Q_DECLARE_METATYPE(Sink::ApplicationDomain::Entity)
diff --git a/common/domain/event.cpp b/common/domain/event.cpp
index 96e2d44..0909bf1 100644
--- a/common/domain/event.cpp
+++ b/common/domain/event.cpp
@@ -68,19 +68,19 @@ void TypeImplementation<Event>::removeIndex(const QByteArray &identifier, const
 QSharedPointer<ReadPropertyMapper<TypeImplementation<Event>::Buffer> > TypeImplementation<Event>::initializeReadPropertyMapper()
 {
     auto propertyMapper = QSharedPointer<ReadPropertyMapper<Buffer> >::create();
-    propertyMapper->addMapping<QString, Buffer>("summary", &Buffer::summary);
-    propertyMapper->addMapping<QString, Buffer>("description", &Buffer::description);
-    propertyMapper->addMapping<QString, Buffer>("uid", &Buffer::uid);
-    propertyMapper->addMapping<QByteArray, Buffer>("attachment", &Buffer::attachment);
+    propertyMapper->addMapping<Event::Summary, Buffer>(&Buffer::summary);
+    propertyMapper->addMapping<Event::Description, Buffer>(&Buffer::description);
+    propertyMapper->addMapping<Event::Uid, Buffer>(&Buffer::uid);
+    propertyMapper->addMapping<Event::Attachment, Buffer>(&Buffer::attachment);
     return propertyMapper;
 }
 
 QSharedPointer<WritePropertyMapper<TypeImplementation<Event>::BufferBuilder> > TypeImplementation<Event>::initializeWritePropertyMapper()
 {
     auto propertyMapper = QSharedPointer<WritePropertyMapper<BufferBuilder> >::create();
-    propertyMapper->addMapping<QString>("summary", &BufferBuilder::add_summary);
-    propertyMapper->addMapping<QString>("description", &BufferBuilder::add_description);
-    propertyMapper->addMapping<QString>("uid", &BufferBuilder::add_uid);
-    propertyMapper->addMapping<QByteArray>("attachment", &BufferBuilder::add_attachment);
+    propertyMapper->addMapping<Event::Summary>(&BufferBuilder::add_summary);
+    propertyMapper->addMapping<Event::Description>(&BufferBuilder::add_description);
+    propertyMapper->addMapping<Event::Uid>(&BufferBuilder::add_uid);
+    propertyMapper->addMapping<Event::Attachment>(&BufferBuilder::add_attachment);
     return propertyMapper;
 }
diff --git a/common/domain/folder.cpp b/common/domain/folder.cpp
index faad5a9..309ca3f 100644
--- a/common/domain/folder.cpp
+++ b/common/domain/folder.cpp
@@ -70,19 +70,19 @@ void TypeImplementation<Folder>::removeIndex(const QByteArray &identifier, const
 QSharedPointer<ReadPropertyMapper<TypeImplementation<Folder>::Buffer> > TypeImplementation<Folder>::initializeReadPropertyMapper()
 {
     auto propertyMapper = QSharedPointer<ReadPropertyMapper<Buffer> >::create();
-    propertyMapper->addMapping<QByteArray, Buffer>("parent", &Buffer::parent);
-    propertyMapper->addMapping<QString, Buffer>("name", &Buffer::name);
-    propertyMapper->addMapping<QByteArray, Buffer>("icon", &Buffer::icon);
-    propertyMapper->addMapping<QByteArrayList, Buffer>("specialpurpose", &Buffer::specialpurpose);
+    propertyMapper->addMapping<Folder::Parent, Buffer>(&Buffer::parent);
+    propertyMapper->addMapping<Folder::Name, Buffer>(&Buffer::name);
+    propertyMapper->addMapping<Folder::Icon, Buffer>(&Buffer::icon);
+    propertyMapper->addMapping<Folder::SpecialPurpose, Buffer>(&Buffer::specialpurpose);
     return propertyMapper;
 }
 
 QSharedPointer<WritePropertyMapper<TypeImplementation<Folder>::BufferBuilder> > TypeImplementation<Folder>::initializeWritePropertyMapper()
 {
     auto propertyMapper = QSharedPointer<WritePropertyMapper<BufferBuilder> >::create();
-    propertyMapper->addMapping<QByteArray>("parent", &BufferBuilder::add_parent);
-    propertyMapper->addMapping<QString>("name", &BufferBuilder::add_name);
-    propertyMapper->addMapping<QByteArray>("icon", &BufferBuilder::add_icon);
-    propertyMapper->addMapping<QByteArrayList>("specialpurpose", &BufferBuilder::add_specialpurpose);
+    propertyMapper->addMapping<Folder::Parent>(&BufferBuilder::add_parent);
+    propertyMapper->addMapping<Folder::Name>(&BufferBuilder::add_name);
+    propertyMapper->addMapping<Folder::Icon>(&BufferBuilder::add_icon);
+    propertyMapper->addMapping<Folder::SpecialPurpose>(&BufferBuilder::add_specialpurpose);
     return propertyMapper;
 }
diff --git a/common/domain/mail.cpp b/common/domain/mail.cpp
index 2f3973a..706e410 100644
--- a/common/domain/mail.cpp
+++ b/common/domain/mail.cpp
@@ -75,31 +75,32 @@ void TypeImplementation<Mail>::removeIndex(const QByteArray &identifier, const B
 QSharedPointer<ReadPropertyMapper<TypeImplementation<Mail>::Buffer> > TypeImplementation<Mail>::initializeReadPropertyMapper()
 {
     auto propertyMapper = QSharedPointer<ReadPropertyMapper<Buffer> >::create();
-    propertyMapper->addMapping<QString, Buffer>("uid", &Buffer::uid);
-    propertyMapper->addMapping<QString, Buffer>("sender", &Buffer::sender);
-    propertyMapper->addMapping<QString, Buffer>("senderName", &Buffer::senderName);
-    propertyMapper->addMapping<QString, Buffer>("subject", &Buffer::subject);
-    propertyMapper->addMapping<QDateTime, Buffer>("date", &Buffer::date);
-    propertyMapper->addMapping<bool, Buffer>("unread", &Buffer::unread);
-    propertyMapper->addMapping<bool, Buffer>("important", &Buffer::important);
-    propertyMapper->addMapping<QByteArray, Buffer>("folder", &Buffer::folder);
-    propertyMapper->addMapping<QString, Buffer>("mimeMessage", &Buffer::mimeMessage);
-    propertyMapper->addMapping<bool, Buffer>("draft", &Buffer::draft);
+    propertyMapper->addMapping<Mail::Uid, Buffer>(&Buffer::uid);
+    propertyMapper->addMapping<Mail::Sender, Buffer>(&Buffer::sender);
+    propertyMapper->addMapping<Mail::SenderName, Buffer>(&Buffer::senderName);
+    propertyMapper->addMapping<Mail::Subject, Buffer>(&Buffer::subject);
+    propertyMapper->addMapping<Mail::Date, Buffer>(&Buffer::date);
+    propertyMapper->addMapping<Mail::Unread, Buffer>(&Buffer::unread);
+    propertyMapper->addMapping<Mail::Important, Buffer>(&Buffer::important);
+    propertyMapper->addMapping<Mail::Folder, Buffer>(&Buffer::folder);
+    propertyMapper->addMapping<Mail::MimeMessage, Buffer>(&Buffer::mimeMessage);
+    propertyMapper->addMapping<Mail::Draft, Buffer>(&Buffer::draft);
     return propertyMapper;
 }
 
 QSharedPointer<WritePropertyMapper<TypeImplementation<Mail>::BufferBuilder> > TypeImplementation<Mail>::initializeWritePropertyMapper()
 {
     auto propertyMapper = QSharedPointer<WritePropertyMapper<BufferBuilder> >::create();
-    propertyMapper->addMapping<QString>("uid", &BufferBuilder::add_uid);
-    propertyMapper->addMapping<QString>("sender", &BufferBuilder::add_sender);
-    propertyMapper->addMapping<QString>("senderName", &BufferBuilder::add_senderName);
-    propertyMapper->addMapping<QString>("subject", &BufferBuilder::add_subject);
-    propertyMapper->addMapping<QDateTime>("date", &BufferBuilder::add_date);
-    propertyMapper->addMapping<bool>("unread", &BufferBuilder::add_unread);
-    propertyMapper->addMapping<bool>("important", &BufferBuilder::add_important);
-    propertyMapper->addMapping<QByteArray>("folder", &BufferBuilder::add_folder);
-    propertyMapper->addMapping<QString>("mimeMessage", &BufferBuilder::add_mimeMessage);
-    propertyMapper->addMapping<bool>("draft", &BufferBuilder::add_draft);
+
+    propertyMapper->addMapping<Mail::Uid>(&BufferBuilder::add_uid);
+    propertyMapper->addMapping<Mail::Sender>(&BufferBuilder::add_sender);
+    propertyMapper->addMapping<Mail::SenderName>(&BufferBuilder::add_senderName);
+    propertyMapper->addMapping<Mail::Subject>(&BufferBuilder::add_subject);
+    propertyMapper->addMapping<Mail::Date>(&BufferBuilder::add_date);
+    propertyMapper->addMapping<Mail::Unread>(&BufferBuilder::add_unread);
+    propertyMapper->addMapping<Mail::Important>(&BufferBuilder::add_important);
+    propertyMapper->addMapping<Mail::Folder>(&BufferBuilder::add_folder);
+    propertyMapper->addMapping<Mail::MimeMessage>(&BufferBuilder::add_mimeMessage);
+    propertyMapper->addMapping<Mail::Draft>(&BufferBuilder::add_draft);
     return propertyMapper;
 }
diff --git a/common/propertymapper.h b/common/propertymapper.h
index edbc7f1..8227940 100644
--- a/common/propertymapper.h
+++ b/common/propertymapper.h
@@ -78,33 +78,33 @@ public:
     }
 
     template <typename T, typename Buffer>
-    void addMapping(const QByteArray &name, const flatbuffers::String *(Buffer::*f)() const)
+    void addMapping(const flatbuffers::String *(Buffer::*f)() const)
     {
-        addMapping(name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<T>((buffer->*f)()); });
+        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
     }
 
     template <typename T, typename Buffer>
-    void addMapping(const QByteArray &name, uint8_t (Buffer::*f)() const)
+    void addMapping(uint8_t (Buffer::*f)() const)
     {
-        addMapping(name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<T>((buffer->*f)()); });
+        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
     }
 
     template <typename T, typename Buffer>
-    void addMapping(const QByteArray &name, bool (Buffer::*f)() const)
+    void addMapping(bool (Buffer::*f)() const)
     {
-        addMapping(name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<T>((buffer->*f)()); });
+        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
     }
 
     template <typename T, typename Buffer>
-    void addMapping(const QByteArray &name, const flatbuffers::Vector<uint8_t> *(Buffer::*f)() const)
+    void addMapping(const flatbuffers::Vector<uint8_t> *(Buffer::*f)() const)
     {
-        addMapping(name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<T>((buffer->*f)()); });
+        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
     }
 
     template <typename T, typename Buffer>
-    void addMapping(const QByteArray &name, const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *(Buffer::*f)() const)
+    void addMapping(const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *(Buffer::*f)() const)
     {
-        addMapping(name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<T>((buffer->*f)()); });
+        addMapping(T::name, [f](Buffer const *buffer) -> QVariant { return propertyToVariant<typename T::Type>((buffer->*f)()); });
     }
 
 private:
@@ -134,44 +134,44 @@ public:
     }
 
     template <typename T>
-    void addMapping(const QByteArray &name, void (BufferBuilder::*f)(uint8_t))
+    void addMapping(void (BufferBuilder::*f)(uint8_t))
     {
-        addMapping(name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            return [value, f](BufferBuilder &builder) { (builder.*f)(value.value<T>()); };
+        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+            return [value, f](BufferBuilder &builder) { (builder.*f)(value.value<typename T::Type>()); };
         });
     }
 
     template <typename T>
-    void addMapping(const QByteArray &name, void (BufferBuilder::*f)(bool))
+    void addMapping(void (BufferBuilder::*f)(bool))
     {
-        addMapping(name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            return [value, f](BufferBuilder &builder) { (builder.*f)(value.value<T>()); };
+        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+            return [value, f](BufferBuilder &builder) { (builder.*f)(value.value<typename T::Type>()); };
         });
     }
 
     template <typename T>
-    void addMapping(const QByteArray &name, void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::String>))
+    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::String>))
     {
-        addMapping(name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            auto offset = variantToProperty<T>(value, fbb);
+        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+            auto offset = variantToProperty<typename T::Type>(value, fbb);
             return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
         });
     }
 
     template <typename T>
-    void addMapping(const QByteArray &name, void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<uint8_t>>))
+    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<uint8_t>>))
     {
-        addMapping(name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            auto offset = variantToProperty<T>(value, fbb);
+        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+            auto offset = variantToProperty<typename T::Type>(value, fbb);
             return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
         });
     }
 
     template <typename T>
-    void addMapping(const QByteArray &name, void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>))
+    void addMapping(void (BufferBuilder::*f)(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>))
     {
-        addMapping(name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
-            auto offset = variantToProperty<T>(value, fbb);
+        addMapping(T::name, [f](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(BufferBuilder &)> {
+            auto offset = variantToProperty<typename T::Type>(value, fbb);
             return [offset, f](BufferBuilder &builder) { (builder.*f)(offset); };
         });
     }
-- 
cgit v1.2.3