1 files changed, 176 insertions, 0 deletions

diff --git a/client/clientapi.h b/client/clientapi.h
new file mode 100644
index 0000000..b035708
--- /dev/null
+++ b/client/clientapi.h
@@ -0,0 +1,176 @@
+#pragma once
+
+#include <QString>
+#include <QSet>
+
+namespace ClientAPI {
+
+template<class T>
+class Set {
+
+};
+
+template<class T>
+class TreeSet : public Set<T> {
+
+};
+
+class DomainObject {
+
+};
+
+/*
+ * 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 DomainAdapter : public DomainObject {
+    // virtual void setFoo(const QString &value)
+    // {
+    //     mBuffer.setFoo(value);
+    // }
+
+    // virtual QString foo() const
+    // {
+    //     return mBuffer.foo();
+    // }
+
+    // MessageBuffer mBuffer;
+};
+
+
+/**
+ * A query that matches a set of objects
+ */
+class Query
+{
+public:
+    QSet<QString> resources() const { return QSet<QString>(); }
+};
+
+/**
+ * Interface for the store facade
+ */
+template<class DomainType>
+class StoreFacade {
+public:
+    virtual void create(const DomainType &domainObject) = 0;
+    virtual void modify(const DomainType &domainObject) = 0;
+    virtual void remove(const DomainType &domainObject) = 0;
+    virtual void load(const Query &query) = 0;
+};
+
+
+class ResourceImpl {
+
+};
+
+/**
+ * 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
+ * 
+ * This interface should be executed in a thread so we can synchronously retrieve data from the store.
+ */
+template<class DomainType>
+class StoreFacadeImpl : public StoreFacade<DomainType> {
+public:
+    void create(const DomainType &domainObject) {
+        //FIXME here we would need to cast to DomainAdapter
+        //Do actual work
+    }
+
+    void modify(const DomainType &domainObject) {
+        //Do actual work
+    }
+
+    void remove(const DomainType &domainObject) {
+        //Do actual work
+    }
+
+    Set<DomainType> load(Query) {
+        Set<DomainType> resultSet;
+
+        //retrieve results from store and fill into result set
+
+        resultSet << 
+
+        return resultSet;
+    }
+
+private:
+    ResourceImpl resource;
+};
+
+/**
+ * Facade factory that returns a store facade implementation, by loading a plugin and providing the relevant implementation.
+ */
+class FacadeFactory {
+public:
+    template<class DomainType>
+    static StoreFacade<DomainType> getFacade(const QString &resource)
+    {
+        if (resource == "resourceX") {
+            return StoreFacadeImpl<DomainType>();
+        }
+        return StoreFacadeImpl<DomainType>();
+    }
+};
+
+/**
+ * Store interface used in the client API
+ */
+class Store {
+public:
+    template <class DomainType>
+    static Set<DomainType> load(Query)
+    {
+        //Query all resources and aggregate results
+        //Query tells us in which resources we're interested
+        Set<DomainType> resultSet;
+
+        //FIXME this should run in a thread.
+        //The result set is immediately returned and a "promise"/"resultprovider",
+        //is passed to the actual query. The resultset is threadsafe so the query thread can safely move data
+        //via the promise to the mainthread.
+        for(auto resource, query.resources()) {
+            auto facade = FacadeFactory::getFacade(resource);
+            resultSet += facade.load<DomainType>(query);
+        }
+        return resultSet;
+    }
+
+    //Future load(id); => Set with single value
+
+    template <class DomainType>
+    static TreeSet<DomainType> loadTree(Query)
+    {
+
+    }
+
+    //Sync methods for modifications
+    template <class DomainType>
+    static void create(const DomainType &domainObject) {
+        auto facade = FacadeFactory::getFacade(domainObject.resource());
+        facade.create(domainObject);
+    }
+
+    template <class DomainType>
+    static void modify(const DomainType &domainObject) {
+        auto facade = FacadeFactory::getFacade(domainObject.resource());
+        facade.modify(domainObject);
+    }
+
+    template <class DomainType>
+    static void remove(const DomainType &domainObject) {
+        auto facade = FacadeFactory::getFacade(domainObject.resource());
+        facade.remove(domainObject);
+    }
+};
+
+}