Shared domain adaptors between resource and facade.

3 files changed, 86 insertions, 0 deletions

diff --git a/common/domainadaptor.h b/common/domainadaptor.h
new file mode 100644
index 0000000..e8f586b
--- /dev/null
+++ b/common/domainadaptor.h
@@ -0,0 +1,77 @@
+/*
+ * 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 "entity_generated.h"
+#include <QVariant>
+#include <QString>
+#include <functional>
+#include "clientapi.h" //for domain parts
+
+/**
+ * The property mapper holds accessor functions for all properties.
+ *
+ * It is by default initialized with accessors that access the local-only buffer,
+ * and resource simply have to overwrite those accessors.
+ */
+template<typename BufferType>
+class PropertyMapper
+{
+public:
+    void setProperty(const QString &key, const QVariant &value, BufferType *buffer)
+    {
+        if (mWriteAccessors.contains(key)) {
+            auto accessor = mWriteAccessors.value(key);
+            return accessor(value, buffer);
+        }
+    }
+
+    virtual QVariant getProperty(const QString &key, BufferType const *buffer) const
+    {
+        if (mReadAccessors.contains(key)) {
+            auto accessor = mReadAccessors.value(key);
+            return accessor(buffer);
+        }
+        return QVariant();
+    }
+    QHash<QString, std::function<QVariant(BufferType const *)> > mReadAccessors;
+    QHash<QString, std::function<void(const QVariant &, BufferType*)> > mWriteAccessors;
+};
+
+//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
+// {
+// };
+
+template<typename DomainType, typename LocalBuffer, typename ResourceBuffer>
+class DomainTypeAdaptorFactory/* <typename DomainType, LocalBuffer, ResourceBuffer> */
+{
+public:
+    virtual QSharedPointer<Akonadi2::Domain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity) = 0;
+
+protected:
+    QSharedPointer<PropertyMapper<LocalBuffer> > mLocalMapper;
+    QSharedPointer<PropertyMapper<ResourceBuffer> > mResourceMapper;
+};
+
+
diff --git a/common/pipeline.cpp b/common/pipeline.cpp
index 8d00480..18b6d51 100644
--- a/common/pipeline.cpp
+++ b/common/pipeline.cpp
@@ -189,6 +189,7 @@ public:
     Pipeline *pipeline;
     Pipeline::Type type;
     QByteArray key;
+    Akonadi2::Entity *entity;
     QVectorIterator<Preprocessor *> filterIt;
     bool idle;
 };
@@ -239,6 +240,11 @@ Pipeline::Type PipelineState::type() const
     return d->type;
 }
 
+const Akonadi2::Entity &PipelineState::entity() const
+{
+    return *d->entity;
+}
+
 void PipelineState::step()
 {
     if (!d->pipeline) {
diff --git a/common/pipeline.h b/common/pipeline.h
index 8373899..6005331 100644
--- a/common/pipeline.h
+++ b/common/pipeline.h
@@ -29,6 +29,8 @@
 #include <storage.h>
 #include <clientapi.h> //For domain types
 
+#include "entity_generated.h"
+
 namespace Akonadi2
 {
 
@@ -112,6 +114,7 @@ public:
     bool isIdle() const;
     QByteArray key() const;
     Pipeline::Type type() const;
+    const Akonadi2::Entity &entity() const;
 
     void step();
     void processingCompleted(Preprocessor *filter);