From ea348c62fdebe1d9c6531fc4491d3316a1e941df Mon Sep 17 00:00:00 2001
From: Christian Mollekopf <chrigi_1@fastmail.fm>
Date: Fri, 10 Apr 2015 12:32:03 +0200
Subject: checkpoint

---
 dummyresource/domainadaptor.cpp | 111 +++++++++++++++++++++++++++++++++-------
 dummyresource/domainadaptor.h   |   4 ++
 2 files changed, 96 insertions(+), 19 deletions(-)

(limited to 'dummyresource')

diff --git a/dummyresource/domainadaptor.cpp b/dummyresource/domainadaptor.cpp
index 74a8dd6..00af3fe 100644
--- a/dummyresource/domainadaptor.cpp
+++ b/dummyresource/domainadaptor.cpp
@@ -14,42 +14,115 @@
 using namespace DummyCalendar;
 using namespace flatbuffers;
 
+/**
+ * Defines how to convert qt primitives to flatbuffer ones
+ * TODO: rename to createProperty or so?
+ */
+template <class T>
+uoffset_t extractProperty(const QVariant &, flatbuffers::FlatBufferBuilder &fbb);
+
+template <>
+uoffset_t extractProperty<QString>(const QVariant &property, flatbuffers::FlatBufferBuilder &fbb)
+{
+    if (property.isValid()) {
+        return fbb.CreateString(property.toString().toStdString()).o;
+    }
+    return 0;
+}
+
+/**
+ * Create a buffer from a domain object using the provided mappings
+ */
+template <class Builder>
+void 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()) {
+        const auto value = domainObject.getProperty(property);
+        if (mapper.hasMapping(property)) {
+            mapper.setProperty(property, domainObject.getProperty(property), propertiesToAddToResource, fbb);
+        }
+    }
+
+    //Then create all porperties using the above generated builderCalls
+    Builder builder(fbb);
+    for (auto propertyBuilder : propertiesToAddToResource) {
+        propertyBuilder(builder);
+    }
+    builder.Finish();
+}
+
+
 
 DummyEventAdaptorFactory::DummyEventAdaptorFactory()
     : DomainTypeAdaptorFactory()
 {
-    //TODO turn this into initializePropertyMapper as well?
-    mResourceMapper = QSharedPointer<PropertyMapper<DummyEvent> >::create();
-    mResourceMapper->mReadAccessors.insert("summary", [](DummyEvent const *buffer) -> QVariant {
+    //TODO turn this into initializeReadPropertyMapper as well?
+    mResourceMapper = QSharedPointer<ReadPropertyMapper<DummyEvent> >::create();
+    mResourceMapper->addMapping("summary", [](DummyEvent const *buffer) -> QVariant {
         if (buffer->summary()) {
             return QString::fromStdString(buffer->summary()->c_str());
         }
         return QVariant();
     });
+
+    mResourceWriteMapper->addMapping("summary", [](const QVariant &value, flatbuffers::FlatBufferBuilder &fbb) -> std::function<void(DummyEventBuilder &)> {
+        auto offset = extractProperty<QString>(value, fbb);
+        return [offset](DummyEventBuilder &builder) { builder.add_summary(offset); };
+    });
 }
 
 
 void DummyEventAdaptorFactory::createBuffer(const Akonadi2::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb)
 {
-    flatbuffers::FlatBufferBuilder eventFbb;
-    eventFbb.Clear();
-    {
-        auto summary = eventFbb.CreateString(event.getProperty("summary").toString().toStdString());
-        DummyCalendar::DummyEventBuilder eventBuilder(eventFbb);
-        eventBuilder.add_summary(summary);
-        auto eventLocation = eventBuilder.Finish();
-        DummyCalendar::FinishDummyEventBuffer(eventFbb, eventLocation);
-    }
+    // flatbuffers::FlatBufferBuilder resFbb;
+    // flatbuffers::FlatBufferBuilder localFbb;
+
+    // QList<std::function<void(DummyEventBuilder &)> > propertiesToAddToResource;
+    // QList<std::function<void(Akonadi2::ApplicationDomain::Buffer::EventBuilder &)> > propertiesToAddToLocal;
+    // for (const auto &property : event.changedProperties()) {
+    //     const auto value = event.getProperty(property);
+    //     if (mResourceWriteMapper && mResourceWriteMapper->hasMapping(property)) {
+    //         mResourceWriteMapper->setProperty(property, value, propertiesToAddToResource, resFbb);
+    //     } if (mLocalWriteMapper && mLocalWriteMapper->hasMapping(property)) {
+    //         mLocalWriteMapper->setProperty(property, value, propertiesToAddToLocal, localFbb);
+    //     }
+    // }
 
+    // DummyEventBuilder resBuilder(resFbb);
+    // for (auto propertyBuilder : propertiesToAddToResource) {
+    //     propertyBuilder(resBuilder);
+    // }
+    // resBuilder.Finish();
+
+    // DummyEventBuilder localBuilder(localFbb);
+    // for (auto propertyBuilder : propertiesToAddToResource) {
+    //     propertyBuilder(localBuilder);
+    // }
+    // localBuilder.Finish();
+
+    // TODO: how does a resource specify what goes to a local buffer and what it stores separately?
+    // flatbuffers::FlatBufferBuilder eventFbb;
+    // {
+    //     auto summary = extractProperty<QString>(event.getProperty("summary"), fbb);
+    //     DummyCalendar::DummyEventBuilder eventBuilder(eventFbb);
+    //     eventBuilder.add_summary(summary);
+    //     auto eventLocation = eventBuilder.Finish();
+    //     DummyCalendar::FinishDummyEventBuffer(eventFbb, eventLocation);
+    // }
+
+    //TODO we should only copy values into the local buffer that haven't already been copied by the resource buffer
     flatbuffers::FlatBufferBuilder localFbb;
-    {
-        auto uid = localFbb.CreateString(event.getProperty("uid").toString().toStdString());
-        auto localBuilder = Akonadi2::ApplicationDomain::Buffer::EventBuilder(localFbb);
-        localBuilder.add_uid(uid);
-        auto location = localBuilder.Finish();
-        Akonadi2::ApplicationDomain::Buffer::FinishEventBuffer(localFbb, location);
+    if (mLocalWriteMapper) {
+        createBufferPart<Akonadi2::ApplicationDomain::Buffer::EventBuilder>(event, localFbb, *mLocalWriteMapper);
+    }
+
+    flatbuffers::FlatBufferBuilder resFbb;
+    if (mResourceWriteMapper) {
+        createBufferPart<DummyEventBuilder>(event, resFbb, *mResourceWriteMapper);
     }
 
-    Akonadi2::EntityBuffer::assembleEntityBuffer(fbb, 0, 0, eventFbb.GetBufferPointer(), eventFbb.GetSize(), localFbb.GetBufferPointer(), localFbb.GetSize());
+    Akonadi2::EntityBuffer::assembleEntityBuffer(fbb, 0, 0, resFbb.GetBufferPointer(), resFbb.GetSize(), localFbb.GetBufferPointer(), localFbb.GetSize());
 }
 
diff --git a/dummyresource/domainadaptor.h b/dummyresource/domainadaptor.h
index 0e2b883..39028c9 100644
--- a/dummyresource/domainadaptor.h
+++ b/dummyresource/domainadaptor.h
@@ -11,4 +11,8 @@ public:
     DummyEventAdaptorFactory();
     virtual ~DummyEventAdaptorFactory() {};
     virtual void createBuffer(const Akonadi2::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb);
+
+private:
+    QSharedPointer<WritePropertyMapper<DummyCalendar::DummyEventBuilder> > mResourceWriteMapper;
+    QSharedPointer<WritePropertyMapper<Akonadi2::ApplicationDomain::Buffer::EventBuilder> > mLocalWriteMapper;
 };
-- 
cgit v1.2.3