2 files changed, 60 insertions, 7 deletions

diff --git a/common/domainadaptor.h b/common/domainadaptor.h
index d07a2bd..fd015b5 100644
--- a/common/domainadaptor.h
+++ b/common/domainadaptor.h
@@ -171,13 +171,22 @@ QSharedPointer<ReadPropertyMapper<T> > initializeReadPropertyMapper();
 template <class T>
 QSharedPointer<WritePropertyMapper<T> > initializeWritePropertyMapper();
 
+template<typename DomainType>
+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;
+};
+
 /**
  * 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, typename LocalBuilder, typename ResourceBuilder>
-class DomainTypeAdaptorFactory
+class DomainTypeAdaptorFactory : public DomainTypeAdaptorFactoryInterface<DomainType>
 {
 public:
     DomainTypeAdaptorFactory() :
@@ -193,7 +202,7 @@ public:
      * 
      * This returns by default a GenericBufferAdaptor initialized with the corresponding property mappers.
      */
-    virtual QSharedPointer<Akonadi2::ApplicationDomain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity)
+    virtual QSharedPointer<Akonadi2::ApplicationDomain::BufferAdaptor> createAdaptor(const Akonadi2::Entity &entity) Q_DECL_OVERRIDE
     {
         const auto resourceBuffer = Akonadi2::EntityBuffer::readBuffer<ResourceBuffer>(entity.resource());
         const auto localBuffer = Akonadi2::EntityBuffer::readBuffer<LocalBuffer>(entity.local());
@@ -207,7 +216,7 @@ public:
         return adaptor;
     }
 
-    virtual void createBuffer(const Akonadi2::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb) {};
+    virtual void createBuffer(const Akonadi2::ApplicationDomain::Event &event, flatbuffers::FlatBufferBuilder &fbb) Q_DECL_OVERRIDE {};
 
 protected:
     QSharedPointer<ReadPropertyMapper<LocalBuffer> > mLocalMapper;
diff --git a/common/facade.h b/common/facade.h
index 6c1ad67..a5858d5 100644
--- a/common/facade.h
+++ b/common/facade.h
@@ -84,14 +84,29 @@ namespace Akonadi2 {
     class ResourceAccess;
 /**
  * Default facade implementation for resources that are implemented in a separate process using the ResourceAccess class.
+ * 
+ * Ideally a basic resource has no implementation effort for the facades and can simply instanciate default implementations (meaning it only has to implement the factory with all supported types).
+ * A resource has to implement:
+ * * A facade factory registering all available facades
+ * * An adaptor factory if it uses special resource buffers (default implementation can be used otherwise)
+ * * A mapping between resource and buffertype if default can't be used.
+ *
+ * Additionally a resource only has to provide a synchronizer plugin to execute the synchronization
  */
 template <typename DomainType>
 class GenericFacade: public Akonadi2::StoreFacade<DomainType>
 {
 public:
-    GenericFacade(const QByteArray &resourceIdentifier)
+    /**
+     * Create a new GenericFacade
+     * 
+     * @param resourceIdentifier is the identifier of the resource instance
+     * @param adaptorFactory is the adaptor factory used to generate the mappings from domain to resource types and vice versa
+     */
+    GenericFacade(const QByteArray &resourceIdentifier, const QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > &adaptorFactory = QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> >())
         : Akonadi2::StoreFacade<DomainType>(),
-        mResourceAccess(new ResourceAccess(resourceIdentifier))
+        mResourceAccess(new ResourceAccess(resourceIdentifier)),
+        mDomainTypeAdaptorFactory(adaptorFactory)
     {
     }
 
@@ -99,6 +114,34 @@ public:
     {
     }
 
+    static QByteArray bufferTypeForDomainType()
+    {
+        //We happen to have a one to one mapping
+        return Akonadi2::ApplicationDomain::getTypeName<DomainType>();
+    }
+
+    Async::Job<void> create(const Akonadi2::ApplicationDomain::Event &domainObject) Q_DECL_OVERRIDE
+    {
+        if (!mDomainTypeAdaptorFactory) {
+            Warning() << "No domain type adaptor factory available";
+        }
+        flatbuffers::FlatBufferBuilder entityFbb;
+        mDomainTypeAdaptorFactory->createBuffer(domainObject, entityFbb);
+        return sendCreateCommand(bufferTypeForDomainType(), QByteArray::fromRawData(reinterpret_cast<const char*>(entityFbb.GetBufferPointer()), entityFbb.GetSize()));
+    }
+
+    Async::Job<void> modify(const Akonadi2::ApplicationDomain::Event &domainObject) Q_DECL_OVERRIDE
+    {
+        //TODO
+        return Async::null<void>();
+    }
+
+    Async::Job<void> remove(const Akonadi2::ApplicationDomain::Event &domainObject) Q_DECL_OVERRIDE
+    {
+        //TODO
+        return Async::null<void>();
+    }
+
     //TODO JOBAPI return job from sync continuation to execute it as subjob?
     Async::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > &resultProvider) Q_DECL_OVERRIDE
     {
@@ -142,11 +185,11 @@ public:
     }
 
 protected:
-    Async::Job<void> sendCreateCommand(const QByteArray &t, const QByteArray &buffer)
+    Async::Job<void> sendCreateCommand(const QByteArray &resourceBufferType, const QByteArray &buffer)
     {
         flatbuffers::FlatBufferBuilder fbb;
         //This is the resource buffer type and not the domain type
-        auto type = fbb.CreateString(t.constData());
+        auto type = fbb.CreateString(resourceBufferType.constData());
         auto delta = Akonadi2::EntityBuffer::appendAsVector(fbb, buffer.constData(), buffer.size());
         auto location = Akonadi2::Commands::CreateCreateEntity(fbb, type, delta);
         Akonadi2::Commands::FinishCreateEntityBuffer(fbb, location);
@@ -177,6 +220,7 @@ protected:
 protected:
     //TODO use one resource access instance per application => make static
     QSharedPointer<Akonadi2::ResourceAccess> mResourceAccess;
+    QSharedPointer<DomainTypeAdaptorFactoryInterface<DomainType> > mDomainTypeAdaptorFactory;
 };
 
 }