1 files changed, 236 insertions, 151 deletions

diff --git a/client/clientapi.h b/client/clientapi.h
index 4e98d05..4ec90e2 100644
--- a/client/clientapi.h
+++ b/client/clientapi.h
@@ -4,7 +4,6 @@
 #include <QSet>
 #include <QSharedPointer>
 #include <functional>
-#include "store/database.h"
 
 namespace async {
     //This should abstract if we execute from eventloop or in thread.
@@ -18,9 +17,74 @@ namespace async {
         timer->start(0);
     };
 
+    /**
+    * Query result set
+    *
+    * This should probably become part of a generic kasync library.
+    *
+    * Functional is nice because we don't have to store data in the emitter
+    * Non functional and storing may be the right thing because we want an in-memory representation of the set
+    * non-functional also allows us to batch move data across thread boundaries.
+    */
+
+    template<class T>
+    class ResultEmitter;
+
+    /*
+    * The promise side for the result provider
+    */
+    template<class T>
+    class ResultProvider {
+    public:
+        void add(const T &value)
+        {
+            //the handler will be called in the other thread, protect
+            mResultEmitter->addHandler(value);
+        }
+
+        void complete()
+        {
+            mResultEmitter->completeHandler();
+        }
+
+        QSharedPointer<ResultEmitter<T> > emitter()
+        {
+            mResultEmitter = QSharedPointer<ResultEmitter<T> >(new ResultEmitter<T>());
+            return mResultEmitter;
+        }
+
+    private:
+        QSharedPointer<ResultEmitter<T> > mResultEmitter;
+    };
+
+    /*
+    * The future side for the client.
+    *
+    * It does not directly hold the state.
+    */
+    template<class DomainType>
+    class ResultEmitter {
+    public:
+        void onAdded(const std::function<void(const DomainType&)> &handler)
+        {
+            addHandler = handler;
+        }
+        // void onRemoved(const std::function<void(const T&)> &handler);
+        void onComplete(const std::function<void(void)> &handler)
+        {
+            completeHandler = handler;
+        }
+
+    private:
+        friend class ResultProvider<DomainType>;
+        std::function<void(const DomainType&)> addHandler;
+        // std::function<void(const T&)> removeHandler;
+        std::function<void(void)> completeHandler;
+    };
+
 }
 
-namespace ClientAPI {
+namespace Akonadi2 {
 
 /**
  * Standardized Domain Types
@@ -32,8 +96,10 @@ namespace ClientAPI {
  *
  * These types will be frequently modified (for every new feature that should be exposed to the any client)
  */
+namespace Domain {
 
 class AkonadiDomainType {
+public:
     /*
      * Each domain object needs to store the resource, identifier, revision triple so we can link back to the storage location.
      */
@@ -58,87 +124,30 @@ class Folder : public AkonadiDomainType {
 
 };
 
-/*
- * Resource and domain object specific
- * FIXME: should we hardcode the requirement that the domain adapter is a subclass for the domain object?
- * * how do we allow copying of domain objects?
- * ** dummy domain object that is a wrapper?
- * ** domain adapter has an accessor for the domain object to hide subclassing
- */
-class EventDomainAdapter : public Event {
-    // virtual void setFoo(const QString &value)
-    // {
-    //     mBuffer.setFoo(value);
-    // }
-
-    // virtual QString foo() const
-    // {
-    //     return mBuffer.foo();
-    // }
-
-    // MessageBuffer mBuffer;
-};
-
-
-
 /**
- * Query result set
- *
- * This should probably become part of a generic kasync library.
- *
- * Functional is nice because we don't have to store data in the emitter
- * Non functional and storing may be the right thing because we want an in-memory representation of the set
- * non-functional also allows us to batch move data across thread boundaries.
- */
-
-template<class T>
-class ResultEmitter;
-
-/*
- * The promise side for the result provider
+ * All types need to be registered here an MUST return a different name.
+ * 
+ * Do not store these types to disk, they may change over time.
  */
-template<class T>
-class ResultProvider {
-public:
-    void add(const T &value)
-    {
-        //the handler will be called in the other thread, protect
-        mResultEmitter->addHandler(value);
-    }
-
-    QSharedPointer<ResultEmitter<T> > emitter()
-    {
-        mResultEmitter = QSharedPointer<ResultEmitter<T> >(new ResultEmitter<T>());
-        return emitter;
-    }
 
-private:
-    QSharedPointer<ResultEmitter<T> > mResultEmitter;
-};
-
-/*
- * The future side for the client.
- *
- * It does not directly hold the state.
- */
-template<class T>
-class ResultEmitter {
-public:
-    void onAdded(const std::function<void(const T&)> &handler);
-    // void onRemoved(const std::function<void(const T&)> &handler);
+template<class DomainType>
+QString getTypeName();
 
-private:
-    friend class SetSource;
-    std::function<void(const T&)> addHandler;
-    // std::function<void(const T&)> removeHandler;
-};
+template<>
+QString getTypeName<Event>()
+{
+    return "event";
+}
 
-// template<class T>
-// class TreeSet : public Set<T> {
-// 
-// };
+template<>
+QString getTypeName<Todo>()
+{
+    return "todo";
+}
 
+}
 
+using namespace async;
 
 /**
  * A query that matches a set of objects
@@ -157,18 +166,22 @@ class Query
 {
 public:
     //Resources to search
-    QSet<QString> resources() const { return QSet<QString>(); }
+    QSet<QString> resources;
 };
 
 
 /**
- * Interface for the store facade
+ * Interface for the store facade.
  * 
  * All methods are synchronous.
+ * Facades are stateful (they hold connections to resources and database).
+ * 
+ * TODO: would it make sense to split the write, read and notification parts? (we could potentially save some connections)
  */
 template<class DomainType>
 class StoreFacade {
 public:
+    virtual ~StoreFacade(){};
     virtual void create(const DomainType &domainObject) = 0;
     virtual void modify(const DomainType &domainObject) = 0;
     virtual void remove(const DomainType &domainObject) = 0;
@@ -177,94 +190,71 @@ public:
 
 
 /**
- * Actual implementation of the store facade that is provided by the resource plugin.
- *
- * It knows the buffer type used by the resource as well as the actual store used.
+ * Facade factory that returns a store facade implementation, by loading a plugin and providing the relevant implementation.
  * 
- * A resource must provide this facade for each domain type it knows.
- * => is reimplemented a lot
- * => we should have a base implementation
+ * If we were to provide default implementations for certain capabilities. Here would be the place to do so.
  * 
- * This interface should be executed in a thread so we can synchronously retrieve data from the store.
- *
- * TODO: perhaps we should also allow async access and leave the thread/non-thread decision up to the implementation?
+ * TODO: pluginmechansims for resources to provide their implementations.
+ * * We may want a way to recycle facades to avoid recreating socket connections all the time?
  */
-template<typename DomainType>
-class StoreFacadeImpl : public StoreFacade<Event> {
-};
 
-template<>
-class StoreFacadeImpl<Event> : public StoreFacade<Event> {
+class FacadeFactory {
 public:
-    void create(const Event &domainObject) {
-        //FIXME here we would need to cast to DomainAdapter
-        //Do actual work
-        //transformFromDomainType(domainObject);
-        //Ideally we have an adapter
-        //getAdater(domainObject).buffer();
-        //domainObject.key(); => The domain object needs to provide the id
-        //writeToDb();
+    //FIXME: proper singleton implementation
+    static FacadeFactory &instance()
+    {
+        static FacadeFactory factory;
+        return factory;
     }
 
-    void modify(const Event &domainObject) {
-        //Do actual work
+    static QString key(const QString &resource, const QString &type)
+    {
+        return resource + type;
     }
 
-    void remove(const Event &domainObject) {
-        //Do actual work
+    template<class DomainType, class Facade>
+    void registerFacade(const QString &resource)
+    {
+        const QString typeName = Domain::getTypeName<DomainType>();
+        mFacadeRegistry.insert(key(resource, typeName), [](){ return new Facade; });
     }
 
-    class EventBuffer {
-        QString value;
-    };
-
-    static Event transformToDomainType(const EventBuffer &buffer) {
-        //We may want to avoid copies here
-        Event event;
-        // //Ideally we don't have to copy and can use an adaptor instead
-        // return DomainAdaptor
-        return event;
-    };
-
-    void load(const Query &query, const std::function<void(const Event &)> &resultCallback) {
-        //retrieve buffers from storage
-        QList<EventBuffer> queryresult;
-        for(const EventBuffer &buffer : queryresult) {
-            resultCallback(transformToDomainType(buffer));
-        }
+    /*
+     * Allows the registrar to register a specific instance.
+     *
+     * Primarily for testing.
+     * The facade factory takes ovnership of the poniter and typically deletes the instance via shared pointer.
+     * Supplied factory functions should therefore always return a new pointer (i.e. via clone())
+     *
+     * FIXME the factory function should really be returning QSharedPointer<void>, which doesn't work (std::shared_pointer<void> would though). That way i.e. a test could keep the object alive until it's done.
+     */
+    template<class DomainType, class Facade>
+    void registerFacade(const QString &resource, const std::function<void*(void)> &customFactoryFunction)
+    {
+        const QString typeName = Domain::getTypeName<DomainType>();
+        mFacadeRegistry.insert(key(resource, typeName), customFactoryFunction);
     }
 
-private:
-    //Dummy implementation
-    class ResourceImpl {};
-    ResourceImpl resource;
-    Database mDb;
-};
-
-/**
- * Facade factory that returns a store facade implementation, by loading a plugin and providing the relevant implementation.
- * 
- * If we were to provide default implementations for certain capabilities. Here would be the place to do so.
- * 
- * TODO: pluginmechansims for resources to provide their implementations.
- */
-class FacadeFactory {
-public:
     template<class DomainType>
-    static StoreFacade<DomainType> getFacade(const QString &resource)
+    QSharedPointer<StoreFacade<DomainType> > getFacade(const QString &resource)
     {
-        //TODO errorhandling in case the resource doesn't support the domain type
-        if (resource == "dummyresource") {
-            return StoreFacadeImpl<DomainType>();
+        const QString typeName = Domain::getTypeName<DomainType>();
+        auto factoryFunction = mFacadeRegistry.value(key(resource, typeName));
+        if (factoryFunction) {
+            return QSharedPointer<StoreFacade<DomainType> >(static_cast<StoreFacade<DomainType>* >(factoryFunction()));
         }
-        return StoreFacadeImpl<DomainType>();
+        qWarning() << "Failed to find facade for resource: " << resource << " and type: " << typeName;
+        return QSharedPointer<StoreFacade<DomainType> >();
     }
+
+private:
+    QHash<QString, std::function<void*(void)> > mFacadeRegistry;
 };
 
 /**
- * Store interface used in the client API
+ * Store interface used in the client API.
  *
- * TODO: For testing we need to be able to inject dummy StoreFacades.
+ * TODO: For testing we need to be able to inject dummy StoreFacades. Should we work with a store instance, or a singleton factory?
  */
 class Store {
 public:
@@ -282,10 +272,13 @@ public:
         async::run([resultSet, query](){
             // Query all resources and aggregate results
             // query tells us in which resources we're interested
-            for(const QString &resource : query.resources()) {
-                auto facade = FacadeFactory::getFacade<DomainType>(resource);
-                facade.load(query, resultSet.add);
+            for(const QString &resource : query.resources) {
+                auto facade = FacadeFactory::instance().getFacade<DomainType>(resource);
+                //We have to bind an instance to the function callback. Since we use a shared pointer this keeps the result provider instance (and thus also the emitter) alive.
+                std::function<void(const DomainType &)> addCallback = std::bind(&ResultProvider<DomainType>::add, resultSet, std::placeholders::_1);
+                facade->load(query, addCallback);
             }
+            resultSet->complete();
         });
         return resultSet->emitter();
     }
@@ -305,7 +298,7 @@ public:
     template <class DomainType>
     static void create(const DomainType &domainObject, const QString &resourceIdentifier) {
         //Potentially move to separate thread as well
-        auto facade = FacadeFactory::getFacade<DomainType>(resourceIdentifier);
+        auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
         facade.create(domainObject);
     }
 
@@ -317,7 +310,7 @@ public:
     template <class DomainType>
     static void modify(const DomainType &domainObject, const QString &resourceIdentifier) {
         //Potentially move to separate thread as well
-        auto facade = FacadeFactory::getFacade<DomainType>(resourceIdentifier);
+        auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
         facade.modify(domainObject);
     }
 
@@ -327,9 +320,101 @@ public:
     template <class DomainType>
     static void remove(const DomainType &domainObject, const QString &resourceIdentifier) {
         //Potentially move to separate thread as well
-        auto facade = FacadeFactory::getFacade<DomainType>(resourceIdentifier);
+        auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
         facade.remove(domainObject);
     }
 };
 
 }
+
+//Example implementations
+/*
+ * Resource and domain object specific
+ * FIXME: should we hardcode the requirement that the domain adapter is a subclass for the domain object?
+ * * how do we allow copying of domain objects?
+ * ** dummy domain object that is a wrapper?
+ * ** domain adapter has an accessor for the domain object to hide subclassing
+ */
+class EventDomainAdapter : public Akonadi2::Domain::Event {
+    // virtual void setFoo(const QString &value)
+    // {
+    //     mBuffer.setFoo(value);
+    // }
+
+    // virtual QString foo() const
+    // {
+    //     return mBuffer.foo();
+    // }
+
+    // MessageBuffer mBuffer;
+};
+
+
+/**
+ * Actual implementation of the store facade that is provided by the resource plugin.
+ *
+ * It knows the buffer type used by the resource as well as the actual store used.
+ * 
+ * A resource must provide this facade for each domain type it knows.
+ * => is reimplemented a lot
+ * => we should have a base implementation
+ * 
+ * This interface should be executed in a thread so we can synchronously retrieve data from the store.
+ *
+ * TODO: perhaps we should also allow async access and leave the thread/non-thread decision up to the implementation?
+ */
+template<typename DomainType>
+class StoreFacadeImpl : public Akonadi2::StoreFacade<Akonadi2::Domain::Event> {
+};
+
+template<>
+class StoreFacadeImpl<Akonadi2::Domain::Event> : public Akonadi2::StoreFacade<Akonadi2::Domain::Event> {
+public:
+    StoreFacadeImpl():StoreFacade() {};
+
+    void create(const Akonadi2::Domain::Event &domainObject) {
+        //FIXME here we would need to cast to DomainAdapter
+        //Do actual work
+        //transformFromDomainType(domainObject);
+        //Ideally we have an adapter
+        //getAdater(domainObject).buffer();
+        //domainObject.key(); => The domain object needs to provide the id
+        //writeToDb();
+    }
+
+    void modify(const Akonadi2::Domain::Event &domainObject) {
+        //Do actual work
+    }
+
+    void remove(const Akonadi2::Domain::Event &domainObject) {
+        //Do actual work
+    }
+
+    class EventBuffer {
+        QString value;
+    };
+
+    static Akonadi2::Domain::Event transformToDomainType(const EventBuffer &buffer) {
+        //We may want to avoid copies here
+        Akonadi2::Domain::Event event;
+        // //Ideally we don't have to copy and can use an adaptor instead
+        // return DomainAdaptor
+        return event;
+    };
+
+    void load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event &)> &resultCallback) {
+        //retrieve buffers from storage
+        QList<EventBuffer> queryresult;
+        for(const EventBuffer &buffer : queryresult) {
+            resultCallback(transformToDomainType(buffer));
+        }
+    }
+
+private:
+    //Dummy implementation
+    class ResourceImpl {};
+    ResourceImpl resource;
+    class DatabaseImpl {};
+    DatabaseImpl mDb;
+};
+