1 files changed, 51 insertions, 46 deletions

diff --git a/common/clientapi.h b/common/clientapi.h
index 63305ab..22448b3 100644
--- a/common/clientapi.h
+++ b/common/clientapi.h
@@ -163,7 +163,7 @@ namespace async {
 namespace Akonadi2 {
 
 /**
- * Standardized Domain Types
+ * Standardized Application Domain Types
  *
  * They don't adhere to any standard and can be freely extended
  * Their sole purpose is providing a standardized interface to access data.
@@ -172,7 +172,7 @@ namespace Akonadi2 {
  *
  * These types will be frequently modified (for every new feature that should be exposed to the any client)
  */
-namespace Domain {
+namespace ApplicationDomain {
 
 /**
  * This class has to be implemented by resources and can be used as generic interface to access the buffer properties
@@ -180,9 +180,9 @@ namespace Domain {
 class BufferAdaptor {
 public:
     virtual ~BufferAdaptor() {}
-    virtual QVariant getProperty(const QString &key) const { return QVariant(); }
-    virtual void setProperty(const QString &key, const QVariant &value) {}
-    virtual QStringList availableProperties() const { return QStringList(); }
+    virtual QVariant getProperty(const QByteArray &key) const { return QVariant(); }
+    virtual void setProperty(const QByteArray &key, const QVariant &value) {}
+    virtual QList<QByteArray> availableProperties() const { return QList<QByteArray>(); }
 };
 
 class MemoryBufferAdaptor : public BufferAdaptor {
@@ -202,12 +202,12 @@ public:
 
     virtual ~MemoryBufferAdaptor() {}
 
-    virtual QVariant getProperty(const QString &key) const { return mValues.value(key); }
-    virtual void setProperty(const QString &key, const QVariant &value) { mValues.insert(key, value); }
-    virtual QStringList availableProperties() const { return mValues.keys(); }
+    virtual QVariant getProperty(const QByteArray &key) const { return mValues.value(key); }
+    virtual void setProperty(const QByteArray &key, const QVariant &value) { mValues.insert(key, value); }
+    virtual QByteArrayList availableProperties() const { return mValues.keys(); }
 
 private:
-    QHash<QString, QVariant> mValues;
+    QHash<QByteArray, QVariant> mValues;
 };
 
 /**
@@ -215,14 +215,14 @@ private:
  * * provide a unified interface to read buffers (for zero-copy reading)
  * * record changes to generate changesets for modifications
  */
-class AkonadiDomainType {
+class ApplicationDomainType {
 public:
-    AkonadiDomainType()
+    ApplicationDomainType()
         :mAdaptor(new MemoryBufferAdaptor())
     {
 
     }
-    AkonadiDomainType(const QString &resourceName, const QString &identifier, qint64 revision, const QSharedPointer<BufferAdaptor> &adaptor)
+    ApplicationDomainType(const QByteArray &resourceName, const QByteArray &identifier, qint64 revision, const QSharedPointer<BufferAdaptor> &adaptor)
         : mAdaptor(adaptor),
         mResourceName(resourceName),
         mIdentifier(identifier),
@@ -230,41 +230,43 @@ public:
     {
     }
 
-    virtual ~AkonadiDomainType() {}
+    virtual ~ApplicationDomainType() {}
 
-    virtual QVariant getProperty(const QString &key) const { return mAdaptor->getProperty(key); }
-    virtual void setProperty(const QString &key, const QVariant &value){ mChangeSet.insert(key, value); mAdaptor->setProperty(key, value); }
+    virtual QVariant getProperty(const QByteArray &key) const { return mAdaptor->getProperty(key); }
+    virtual void setProperty(const QByteArray &key, const QVariant &value){ mChangeSet.insert(key, value); mAdaptor->setProperty(key, value); }
+    virtual QByteArrayList changedProperties() const { return mChangeSet.keys(); }
+    qint64 revision() const { return mRevision; }
 
 private:
     QSharedPointer<BufferAdaptor> mAdaptor;
-    QHash<QString, QVariant> mChangeSet;
+    QHash<QByteArray, QVariant> mChangeSet;
     /*
      * Each domain object needs to store the resource, identifier, revision triple so we can link back to the storage location.
      */
     QString mResourceName;
-    QString mIdentifier;
+    QByteArray mIdentifier;
     qint64 mRevision;
 };
 
-struct Event : public AkonadiDomainType {
+struct Event : public ApplicationDomainType {
     typedef QSharedPointer<Event> Ptr;
-    using AkonadiDomainType::AkonadiDomainType;
+    using ApplicationDomainType::ApplicationDomainType;
 };
 
-struct Todo : public AkonadiDomainType {
+struct Todo : public ApplicationDomainType {
     typedef QSharedPointer<Todo> Ptr;
-    using AkonadiDomainType::AkonadiDomainType;
+    using ApplicationDomainType::ApplicationDomainType;
 };
 
-struct Calendar : public AkonadiDomainType {
+struct Calendar : public ApplicationDomainType {
     typedef QSharedPointer<Calendar> Ptr;
-    using AkonadiDomainType::AkonadiDomainType;
+    using ApplicationDomainType::ApplicationDomainType;
 };
 
-class Mail : public AkonadiDomainType {
+class Mail : public ApplicationDomainType {
 };
 
-class Folder : public AkonadiDomainType {
+class Folder : public ApplicationDomainType {
 };
 
 /**
@@ -274,13 +276,13 @@ class Folder : public AkonadiDomainType {
  */
 
 template<class DomainType>
-QString getTypeName();
+QByteArray getTypeName();
 
 template<>
-QString getTypeName<Event>();
+QByteArray getTypeName<Event>();
 
 template<>
-QString getTypeName<Todo>();
+QByteArray getTypeName<Todo>();
 
 }
 
@@ -298,19 +300,22 @@ using namespace async;
  * * what resources to search
  * * filters on various properties (parent collection, startDate range, ....)
  * * properties we need (for on-demand querying)
+ * 
+ * syncOnDemand: Execute a source sync before executing the query
+ * processAll: Ensure all local messages are processed before querying to guarantee an up-to date dataset.
  */
 class Query
 {
 public:
     Query() : syncOnDemand(true), processAll(false) {}
     //Could also be a propertyFilter
-    QStringList resources;
+    QByteArrayList resources;
     //Could also be a propertyFilter
-    QStringList ids;
+    QByteArrayList ids;
     //Filters to apply
-    QHash<QString, QVariant> propertyFilter;
+    QHash<QByteArray, QVariant> propertyFilter;
     //Properties to retrieve
-    QSet<QString> requestedProperties;
+    QSet<QByteArray> requestedProperties;
     bool syncOnDemand;
     bool processAll;
 };
@@ -328,7 +333,7 @@ template<class DomainType>
 class StoreFacade {
 public:
     virtual ~StoreFacade(){};
-    QString type() const { return Domain::getTypeName<DomainType>(); }
+    QByteArray type() const { return ApplicationDomain::getTypeName<DomainType>(); }
     virtual Async::Job<void> create(const DomainType &domainObject) = 0;
     virtual Async::Job<void> modify(const DomainType &domainObject) = 0;
     virtual Async::Job<void> remove(const DomainType &domainObject) = 0;
@@ -351,15 +356,15 @@ public:
         return factory;
     }
 
-    static QString key(const QString &resource, const QString &type)
+    static QByteArray key(const QByteArray &resource, const QByteArray &type)
     {
         return resource + type;
     }
 
     template<class DomainType, class Facade>
-    void registerFacade(const QString &resource)
+    void registerFacade(const QByteArray &resource)
     {
-        const QString typeName = Domain::getTypeName<DomainType>();
+        const QByteArray typeName = ApplicationDomain::getTypeName<DomainType>();
         mFacadeRegistry.insert(key(resource, typeName), [](){ return new Facade; });
     }
 
@@ -373,16 +378,16 @@ public:
      * 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)
+    void registerFacade(const QByteArray &resource, const std::function<void*(void)> &customFactoryFunction)
     {
-        const QString typeName = Domain::getTypeName<DomainType>();
+        const QByteArray typeName = ApplicationDomain::getTypeName<DomainType>();
         mFacadeRegistry.insert(key(resource, typeName), customFactoryFunction);
     }
 
     template<class DomainType>
-    QSharedPointer<StoreFacade<DomainType> > getFacade(const QString &resource)
+    QSharedPointer<StoreFacade<DomainType> > getFacade(const QByteArray &resource)
     {
-        const QString typeName = Domain::getTypeName<DomainType>();
+        const QByteArray typeName = ApplicationDomain::getTypeName<DomainType>();
         auto factoryFunction = mFacadeRegistry.value(key(resource, typeName));
         if (factoryFunction) {
             return QSharedPointer<StoreFacade<DomainType> >(static_cast<StoreFacade<DomainType>* >(factoryFunction()));
@@ -392,7 +397,7 @@ public:
     }
 
 private:
-    QHash<QString, std::function<void*(void)> > mFacadeRegistry;
+    QHash<QByteArray, std::function<void*(void)> > mFacadeRegistry;
 };
 
 /**
@@ -421,7 +426,7 @@ public:
             // query tells us in which resources we're interested
             // TODO: queries to individual resources could be parallelized
             Async::Job<void> job = Async::null<void>();
-            for(const QString &resource : query.resources) {
+            for(const QByteArray &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 typename DomainType::Ptr &)> addCallback = std::bind(&ResultProvider<typename DomainType::Ptr>::add, resultSet, std::placeholders::_1);
@@ -460,7 +465,7 @@ public:
      */
     //TODO return job that tracks progress until resource has stored the message in it's queue?
     template <class DomainType>
-    static void create(const DomainType &domainObject, const QString &resourceIdentifier) {
+    static void create(const DomainType &domainObject, const QByteArray &resourceIdentifier) {
         //Potentially move to separate thread as well
         auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
         auto job = facade->create(domainObject);
@@ -475,7 +480,7 @@ public:
      * This includes moving etc. since these are also simple settings on a property.
      */
     template <class DomainType>
-    static void modify(const DomainType &domainObject, const QString &resourceIdentifier) {
+    static void modify(const DomainType &domainObject, const QByteArray &resourceIdentifier) {
         //Potentially move to separate thread as well
         auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
         facade.modify(domainObject);
@@ -485,13 +490,13 @@ public:
      * Remove an entity.
      */
     template <class DomainType>
-    static void remove(const DomainType &domainObject, const QString &resourceIdentifier) {
+    static void remove(const DomainType &domainObject, const QByteArray &resourceIdentifier) {
         //Potentially move to separate thread as well
         auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceIdentifier);
         facade.remove(domainObject);
     }
 
-    static void shutdown(const QString &resourceIdentifier);
+    static void shutdown(const QByteArray &resourceIdentifier);
 };
 
 }