10 files changed, 602 insertions, 151 deletions

diff --git a/common/clientapi.h b/common/clientapi.h
index 9a32188..a424424 100644
--- a/common/clientapi.h
+++ b/common/clientapi.h
@@ -23,6 +23,7 @@
 #include <QString>
 #include <QSharedPointer>
 #include <QEventLoop>
+#include <QAbstractItemModel>
 #include <functional>
 #include <memory>
 
@@ -101,11 +102,34 @@ public:
     /**
      * Asynchronusly load a dataset with tree structure information
      */
-    // template <class DomainType>
-    // static TreeSet<DomainType> loadTree(Query)
-    // {
+    template <class DomainType>
+    static QSharedPointer<QAbstractItemModel> loadModel(Query query)
+    {
+        auto model = QSharedPointer<ModelResult<DomainType, typename DomainType::Ptr> >::create(query, QList<QByteArray>() << "summary" << "uid");
+        auto resultProvider = QSharedPointer<ModelResultProvider<DomainType, typename DomainType::Ptr> >::create(model);
+
+        // Query all resources and aggregate results
+        KAsync::iterate(getResources(query.resources, ApplicationDomain::getTypeName<DomainType>()))
+        .template each<void, QByteArray>([query, resultProvider](const QByteArray &resource, KAsync::Future<void> &future) {
+            auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceName(resource), resource);
+            if (facade) {
+                facade->load(query, resultProvider).template then<void>([&future](){future.setFinished();}).exec();
+                //Keep the facade alive for the lifetime of the resultSet.
+                resultProvider->setFacade(facade);
+            } else {
+                //Ignore the error and carry on
+                future.setFinished();
+            }
+        }).template then<void>([query, resultProvider]() {
+            resultProvider->initialResultSetComplete();
+            if (!query.liveQuery) {
+                resultProvider->complete();
+            }
+        }).exec();
+
+        return model;
+    }
 
-    // }
     template <class DomainType>
     static std::shared_ptr<StoreFacade<DomainType> > getFacade(const QByteArray &resourceInstanceIdentifier)
     {
diff --git a/common/facade.h b/common/facade.h
index 643ebec..eb55c98 100644
--- a/common/facade.h
+++ b/common/facade.h
@@ -135,68 +135,6 @@ public:
         if (!mResourceAccess) {
             mResourceAccess = QSharedPointer<Akonadi2::ResourceAccess>::create(resourceIdentifier);
         }
-        if (!mStorage) {
-            mStorage = QSharedPointer<EntityStorage<DomainType> >::create(resourceIdentifier);
-            const auto bufferType = bufferTypeForDomainType();
-
-            mStorage->readEntity = [bufferType, this] (const Akonadi2::Storage::Transaction &transaction, const QByteArray &key, const std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &, Akonadi2::Operation)> &resultCallback)
-            {
-                //This only works for a 1:1 mapping of resource to domain types.
-                //Not i.e. for tags that are stored as flags in each entity of an imap store.
-                //additional properties that don't have a 1:1 mapping (such as separately stored tags),
-                //could be added to the adaptor.
-                transaction.openDatabase(bufferType + ".main").findLatest(key, [=](const QByteArray &key, const QByteArray &value) -> bool {
-                    Akonadi2::EntityBuffer buffer(value.data(), value.size());
-                    const Akonadi2::Entity &entity = buffer.entity();
-                    const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(entity.metadata());
-                    Q_ASSERT(metadataBuffer);
-                    const qint64 revision = metadataBuffer ? metadataBuffer->revision() : -1;
-                    resultCallback(DomainType::Ptr::create(mResourceInstanceIdentifier, Akonadi2::Storage::uidFromKey(key), revision, mDomainTypeAdaptorFactory->createAdaptor(entity)), metadataBuffer->operation());
-                    return false;
-                },
-                [](const Akonadi2::Storage::Error &error) {
-                    qWarning() << "Error during query: " << error.message;
-                });
-            };
-
-            mStorage->loadInitialResultSet = [bufferType, this] (const Akonadi2::Query &query, Akonadi2::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters) -> ResultSet
-            {
-                QSet<QByteArray> appliedFilters;
-                auto resultSet = Akonadi2::ApplicationDomain::TypeImplementation<DomainType>::queryIndexes(query, mResourceInstanceIdentifier, appliedFilters, transaction);
-                remainingFilters = query.propertyFilter.keys().toSet() - appliedFilters;
-
-                //We do a full scan if there were no indexes available to create the initial set.
-                if (appliedFilters.isEmpty()) {
-                    //TODO this should be replaced by an index lookup as well
-                    return fullScan(transaction, bufferType);
-                }
-                return resultSet;
-            };
-
-            mStorage->loadIncrementalResultSet = [bufferType, this] (qint64 baseRevision, const Akonadi2::Query &query, Akonadi2::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters) -> ResultSet
-            {
-                auto revisionCounter = QSharedPointer<qint64>::create(baseRevision);
-                return ResultSet([bufferType, revisionCounter, &transaction, this]() -> QByteArray {
-                    const qint64 topRevision = Akonadi2::Storage::maxRevision(transaction);
-                    //Spit out the revision keys one by one.
-                    while (*revisionCounter <= topRevision) {
-                        const auto uid = Akonadi2::Storage::getUidFromRevision(transaction, *revisionCounter);
-                        const auto type = Akonadi2::Storage::getTypeFromRevision(transaction, *revisionCounter);
-                        Trace() << "Revision" << *revisionCounter << type << uid;
-                        if (type != bufferType) {
-                            //Skip revision
-                            *revisionCounter += 1;
-                            continue;
-                        }
-                        const auto key = Akonadi2::Storage::assembleKey(uid, *revisionCounter);
-                        *revisionCounter += 1;
-                        return key;
-                    }
-                    //We're done
-                    return QByteArray();
-                });
-            };
-        }
     }
 
     ~GenericFacade()
@@ -237,13 +175,56 @@ public:
     }
 
     //TODO JOBAPI return job from sync continuation to execute it as subjob?
-    KAsync::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > &resultProvider) Q_DECL_OVERRIDE
+    KAsync::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProviderInterface<typename DomainType::Ptr> > &resultProvider) Q_DECL_OVERRIDE
     {
+        {
+            QSet<QByteArray> remainingFilters;
+            auto filter = [remainingFilters, query](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject) -> bool {
+                for (const auto &filterProperty : remainingFilters) {
+                    //TODO implement other comparison operators than equality
+                    if (domainObject->getProperty(filterProperty) != query.propertyFilter.value(filterProperty)) {
+                        return false;
+                    }
+                }
+                return true;
+            };
+
+            auto fetchEntities = [this, query, resultProvider, filter](const QByteArray &parent) {
+                Trace() << "Running fetchEntities" << parent;
+                Akonadi2::Storage storage(Akonadi2::storageLocation(), mResourceInstanceIdentifier);
+                storage.setDefaultErrorHandler([](const Akonadi2::Storage::Error &error) {
+                    Warning() << "Error during query: " << error.store << error.message;
+                });
+
+                auto transaction = storage.createTransaction(Akonadi2::Storage::ReadOnly);
+
+                auto modifiedQuery = query;
+                modifiedQuery.propertyFilter.insert("parent", parent);
+                //TODO
+                QSet<QByteArray> appliedFilters;
+                auto resultSet = Akonadi2::ApplicationDomain::TypeImplementation<DomainType>::queryIndexes(modifiedQuery, mResourceInstanceIdentifier, appliedFilters, transaction);
+                QSet<QByteArray> remainingFilters = query.propertyFilter.keys().toSet() - appliedFilters;
+
+                //We do a full scan if there were no indexes available to create the initial set.
+                if (appliedFilters.isEmpty()) {
+                    //TODO this should be replaced by an index lookup as well
+                    resultSet = fullScan(transaction, bufferTypeForDomainType());
+                }
+                auto filteredSet = filterSet(resultSet, filter, transaction, true);
+                replaySet(filteredSet, resultProvider);
+                resultProvider->setRevision(Akonadi2::Storage::maxRevision(transaction));
+                qint64 newRevision = Akonadi2::Storage::maxRevision(transaction);
+                //TODO send newRevision to resource
+                // mResourceAccess->sendRevisionReplayedCommand(newRevision);
+            };
+            resultProvider->setFetcher(fetchEntities);
+        }
+
         auto runner = QSharedPointer<QueryRunner>::create(query);
-        QWeakPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > weakResultProvider = resultProvider;
-        runner->setQuery([this, weakResultProvider, query] (qint64 oldRevision) -> KAsync::Job<qint64> {
-            return KAsync::start<qint64>([this, weakResultProvider, query, oldRevision](KAsync::Future<qint64> &future) {
-                Trace() << "Executing query " << oldRevision;
+        QWeakPointer<Akonadi2::ResultProviderInterface<typename DomainType::Ptr> > weakResultProvider = resultProvider;
+        runner->setQuery([this, weakResultProvider, query] () -> KAsync::Job<void> {
+            return KAsync::start<void>([this, weakResultProvider, query](KAsync::Future<void> &future) {
+                Trace() << "Executing query ";
                 auto resultProvider = weakResultProvider.toStrongRef();
                 if (!resultProvider) {
                     Warning() << "Tried executing query after result provider is already gone";
@@ -251,11 +232,10 @@ public:
                     future.setFinished();
                     return;
                 }
-                load(query, resultProvider, oldRevision).template then<void, qint64>([&future, this](qint64 queriedRevision) {
+                executeQuery(query, resultProvider).template then<void, qint64>([&future, this](qint64 queriedRevision) {
                     //TODO set revision in result provider?
                     //TODO update all existing results with new revision
                     mResourceAccess->sendRevisionReplayedCommand(queriedRevision);
-                    future.setValue(queriedRevision);
                     future.setFinished();
                 }).exec();
             });
@@ -272,9 +252,7 @@ public:
 
         //We have to capture the runner to keep it alive
         return synchronizeResource(query).template then<void>([runner](KAsync::Future<void> &future) {
-            runner->run().then<void>([&future]() {
-                future.setFinished();
-            }).exec();
+            future.setFinished();
         },
         [](int error, const QString &errorString) {
             Warning() << "Error during sync " << error << errorString;
@@ -293,17 +271,152 @@ private:
         return KAsync::null<void>();
     }
 
-    virtual KAsync::Job<qint64> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > &resultProvider, qint64 oldRevision)
+    //TODO move into result provider?
+    void replaySet(ResultSet &resultSet, const QSharedPointer<Akonadi2::ResultProviderInterface<typename DomainType::Ptr> > &resultProvider)
+    {
+        while (resultSet.next([this, resultProvider](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &value, Akonadi2::Operation operation) -> bool {
+            switch (operation) {
+            case Akonadi2::Operation_Creation:
+                Trace() << "Got creation";
+                //TODO Only copy in result provider
+                resultProvider->add(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value).template staticCast<DomainType>());
+                // modelResult->add();
+                break;
+            case Akonadi2::Operation_Modification:
+                Trace() << "Got modification";
+                resultProvider->modify(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value).template staticCast<DomainType>());
+                // modelResult->modify();
+                break;
+            case Akonadi2::Operation_Removal:
+                Trace() << "Got removal";
+                resultProvider->remove(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value).template staticCast<DomainType>());
+                // modelResult->remove();
+                break;
+            }
+            return true;
+        })){};
+    }
+
+    void readEntity(const Akonadi2::Storage::Transaction &transaction, const QByteArray &key, const std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &, Akonadi2::Operation)> &resultCallback)
+    {
+        const auto bufferType = bufferTypeForDomainType();
+        //This only works for a 1:1 mapping of resource to domain types.
+        //Not i.e. for tags that are stored as flags in each entity of an imap store.
+        //additional properties that don't have a 1:1 mapping (such as separately stored tags),
+        //could be added to the adaptor.
+        //
+        // Akonadi2::Storage::getLatest(transaction, bufferTye, key);
+        transaction.openDatabase(bufferType + ".main").findLatest(key, [=](const QByteArray &key, const QByteArray &value) -> bool {
+            Akonadi2::EntityBuffer buffer(value.data(), value.size());
+            const Akonadi2::Entity &entity = buffer.entity();
+            const auto metadataBuffer = Akonadi2::EntityBuffer::readBuffer<Akonadi2::Metadata>(entity.metadata());
+            Q_ASSERT(metadataBuffer);
+            const qint64 revision = metadataBuffer ? metadataBuffer->revision() : -1;
+            resultCallback(DomainType::Ptr::create(mResourceInstanceIdentifier, Akonadi2::Storage::uidFromKey(key), revision, mDomainTypeAdaptorFactory->createAdaptor(entity)), metadataBuffer->operation());
+            return false;
+        },
+        [](const Akonadi2::Storage::Error &error) {
+            qWarning() << "Error during query: " << error.message;
+        });
+    }
+
+    ResultSet loadIncrementalResultSet(qint64 baseRevision, const Akonadi2::Query &query, Akonadi2::Storage::Transaction &transaction, QSet<QByteArray> &remainingFilters)
+    {
+
+        const auto bufferType = bufferTypeForDomainType();
+        auto revisionCounter = QSharedPointer<qint64>::create(baseRevision);
+        //TODO apply filter from index
+        return ResultSet([bufferType, revisionCounter, &transaction, this]() -> QByteArray {
+            const qint64 topRevision = Akonadi2::Storage::maxRevision(transaction);
+            //Spit out the revision keys one by one.
+            while (*revisionCounter <= topRevision) {
+                const auto uid = Akonadi2::Storage::getUidFromRevision(transaction, *revisionCounter);
+                const auto type = Akonadi2::Storage::getTypeFromRevision(transaction, *revisionCounter);
+                Trace() << "Revision" << *revisionCounter << type << uid;
+                if (type != bufferType) {
+                    //Skip revision
+                    *revisionCounter += 1;
+                    continue;
+                }
+                const auto key = Akonadi2::Storage::assembleKey(uid, *revisionCounter);
+                *revisionCounter += 1;
+                return key;
+            }
+            //We're done
+            return QByteArray();
+        });
+    }
+
+    ResultSet filterSet(const ResultSet &resultSet, const std::function<bool(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject)> &filter, const Akonadi2::Storage::Transaction &transaction, bool initialQuery)
     {
+        auto resultSetPtr = QSharedPointer<ResultSet>::create(resultSet);
+
+        //Read through the source values and return whatever matches the filter
+        std::function<bool(std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &, Akonadi2::Operation)>)> generator = [this, resultSetPtr, &transaction, filter, initialQuery](std::function<void(const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &, Akonadi2::Operation)> callback) -> bool {
+            while (resultSetPtr->next()) {
+                //TODO only necessary if we actually want to filter or neew the operation type (but not a big deal if we do it always I guess)
+                readEntity(transaction, resultSetPtr->id(), [this, filter, callback, initialQuery](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject, Akonadi2::Operation operation) {
+                    //Always remove removals, they probably don't match due to non-available properties
+                    if (filter(domainObject) || operation == Akonadi2::Operation_Removal) {
+                        if (initialQuery) {
+                            //We're not interested in removals during the initial query
+                            if (operation != Akonadi2::Operation_Removal) {
+                                callback(domainObject, Akonadi2::Operation_Creation);
+                            }
+                        } else {
+                            callback(domainObject, operation);
+                        }
+                    }
+                });
+            }
+            return false;
+        };
+        return ResultSet(generator);
+    }
+
+    virtual KAsync::Job<qint64> executeQuery(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProviderInterface<typename DomainType::Ptr> > &resultProvider)
+    {
+        /*
+         * This method gets called initially, and after every revision change.
+         * * We delegate loading of initial data to the result provider, os it can decide for itself what it needs to load.
+         * * Incremental updates are loaded directly, leaving it up to the model to discard the changes if they are not interesting
+         */
+        const qint64 baseRevision = resultProvider->revision() + 1;
+        Trace() << "Running query " << baseRevision;
+        QSet<QByteArray> remainingFilters;
+        auto filter = [remainingFilters, query, baseRevision](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &domainObject) -> bool {
+            for (const auto &filterProperty : remainingFilters) {
+                //TODO implement other comparison operators than equality
+                if (domainObject->getProperty(filterProperty) != query.propertyFilter.value(filterProperty)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        qint64 newRevision = 0;
+
+        Trace() << "Fetching updates";
+        Akonadi2::Storage storage(Akonadi2::storageLocation(), mResourceInstanceIdentifier);
+        storage.setDefaultErrorHandler([](const Akonadi2::Storage::Error &error) {
+            Warning() << "Error during query: " << error.store << error.message;
+        });
+
+        auto transaction = storage.createTransaction(Akonadi2::Storage::ReadOnly);
+
+        auto resultSet = loadIncrementalResultSet(baseRevision, query, transaction, remainingFilters);
+        auto filteredSet = filterSet(resultSet, filter, transaction, false);
+        replaySet(filteredSet, resultProvider);
+        resultProvider->setRevision(Akonadi2::Storage::maxRevision(transaction));
+        newRevision = Akonadi2::Storage::maxRevision(transaction);
+
         return KAsync::start<qint64>([=]() -> qint64 {
-            return mStorage->read(query, oldRevision, resultProvider);
+            return newRevision;
         });
     }
 
 protected:
     //TODO use one resource access instance per application & per resource
     QSharedPointer<Akonadi2::ResourceAccessInterface> mResourceAccess;
-    QSharedPointer<EntityStorage<DomainType> > mStorage;
     DomainTypeAdaptorFactoryInterface::Ptr mDomainTypeAdaptorFactory;
     QByteArray mResourceInstanceIdentifier;
 };
diff --git a/common/facadeinterface.h b/common/facadeinterface.h
index 3a38db8..571a1e8 100644
--- a/common/facadeinterface.h
+++ b/common/facadeinterface.h
@@ -45,7 +45,7 @@ public:
     virtual KAsync::Job<void> create(const DomainType &domainObject) = 0;
     virtual KAsync::Job<void> modify(const DomainType &domainObject) = 0;
     virtual KAsync::Job<void> remove(const DomainType &domainObject) = 0;
-    virtual KAsync::Job<void> load(const Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > &resultProvider) = 0;
+    virtual KAsync::Job<void> load(const Query &query, const QSharedPointer<Akonadi2::ResultProviderInterface<typename DomainType::Ptr> > &resultProvider) = 0;
 };
 
 template<class DomainType>
@@ -67,7 +67,7 @@ public:
         return KAsync::error<void>(-1, "Failed to create a facade");
     }
 
-    KAsync::Job<void> load(const Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename DomainType::Ptr> > &resultProvider)
+    KAsync::Job<void> load(const Query &query, const QSharedPointer<Akonadi2::ResultProviderInterface<typename DomainType::Ptr> > &resultProvider)
     {
         return KAsync::error<void>(-1, "Failed to create a facade");
     }
diff --git a/common/modelresult.h b/common/modelresult.h
index c23c41e..756f4d6 100644
--- a/common/modelresult.h
+++ b/common/modelresult.h
@@ -24,11 +24,10 @@
 #include <QModelIndex>
 #include <QDebug>
 #include "query.h"
-#include "clientapi.h"
 
 #include "resultprovider.h"
 
-template<class T>
+template<class T, class Ptr>
 class ModelResult : public QAbstractItemModel
 {
 public:
@@ -79,13 +78,18 @@ public:
         return createIndex(row, column, childId);
     }
 
+    QModelIndex createIndexFromId(const qint64 &id) const
+    {
+        auto grandParentId = mParents.value(id, 0);
+        auto row = mTree.value(grandParentId).indexOf(id);
+        return createIndex(row, 0, id);
+    }
+
     QModelIndex parent(const QModelIndex &index) const
     {
         auto id = getIdentifier(index);
         auto parentId = mParents.value(id);
-        auto grandParentId = mParents.value(parentId, 0);
-        auto row = mTree.value(grandParentId).indexOf(parentId);
-        return createIndex(row, 0, parentId);
+        return createIndexFromId(parentId);
     }
 
     bool canFetchMore(const QModelIndex &parent) const
@@ -98,83 +102,92 @@ public:
         fetchEntities(parent);
     }
 
+    qint64 parentId(const Ptr &value)
+    {
+        return qHash(value->getProperty("parent").toByteArray());
+    }
+
+    void add(const Ptr &value)
+    {
+        auto childId = qHash(value->identifier());
+        auto id = parentId(value);
+        auto parent = createIndexFromId(id);
+        qDebug() << "Added entity " << childId;
+        const auto keys = mTree[id];
+        int index = 0;
+        for (; index < keys.size(); index++) {
+            if (childId < keys.at(index)) {
+                break;
+            }
+        }
+        beginInsertRows(parent, index, index);
+        mEntities.insert(childId, value);
+        mTree[id].insert(index, childId);
+        mParents.insert(childId, id);
+        endInsertRows();
+    }
+
+    void modify(const Ptr &value)
+    {
+        auto childId = qHash(value->identifier());
+        auto id = parentId(value);
+        auto parent = createIndexFromId(id);
+        qDebug() << "Modified entity" << childId;
+        auto i = mTree[id].indexOf(childId);
+        mEntities.remove(childId);
+        mEntities.insert(childId, value);
+        //TODO check for change of parents
+        auto idx = index(i, 0, parent);
+        emit dataChanged(idx, idx);
+    }
+
+    void remove(const Ptr &value)
+    {
+        auto childId = qHash(value->identifier());
+        auto id = parentId(value);
+        auto parent = createIndexFromId(id);
+        qDebug() << "Removed entity" << childId;
+        auto index = mTree[id].indexOf(qHash(value->identifier()));
+        beginRemoveRows(parent, index, index);
+        mEntities.remove(childId);
+        mTree[id].removeAll(childId);
+        mParents.remove(childId);
+        //TODO remove children
+        endRemoveRows();
+    }
+
     void fetchEntities(const QModelIndex &parent)
     {
         qDebug() << "Fetching entities";
         const auto id = getIdentifier(parent);
-        // beginResetModel();
-        // mEntities.remove(id);
         mEntityChildrenFetched[id] = true;
-        auto query = mQuery;
+        QByteArray parentIdentifier;
         if (!parent.isValid()) {
             qDebug() << "no parent";
-            query.propertyFilter.insert("parent", QByteArray());
         } else {
             qDebug() << "parent is valid";
-            auto object = parent.data(DomainObjectRole).template value<typename T::Ptr>();
+            auto object = parent.data(DomainObjectRole).template value<Ptr>();
             Q_ASSERT(object);
-            query.propertyFilter.insert("parent", object->identifier());
+            parentIdentifier = object->identifier();
         }
-        auto emitter = Akonadi2::Store::load<T>(query);
-        emitter->onAdded([this, id, parent](const typename T::Ptr &value) {
-            auto childId = qHash(value->identifier());
-            qDebug() << "Added entity " << childId;
-            const auto keys = mTree[id];
-            int index = 0;
-            for (; index < keys.size(); index++) {
-                if (childId < keys.at(index)) {
-                    break;
-                }
-            }
-            beginInsertRows(parent, index, index);
-            mEntities.insert(childId, value);
-            mTree[id].insert(index, childId);
-            mParents.insert(childId, id);
-            endInsertRows();
-        });
-        emitter->onModified([this, id, parent](const typename T::Ptr &value) {
-            auto childId = qHash(value->identifier());
-            qDebug() << "Modified entity" << childId;
-            auto i = mTree[id].indexOf(childId);
-            mEntities.remove(childId);
-            mEntities.insert(childId, value);
-            //TODO check for change of parents
-            auto idx = index(i, 0, parent);
-            emit dataChanged(idx, idx);
-        });
-        emitter->onRemoved([this, id, parent](const typename T::Ptr &value) {
-            auto childId = qHash(value->identifier());
-            qDebug() << "Removed entity" << childId;
-            auto index = mTree[id].indexOf(qHash(value->identifier()));
-            beginRemoveRows(parent, index, index);
-            mEntities.remove(childId);
-            mTree[id].removeAll(childId);
-            mParents.remove(childId);
-            //TODO remove children
-            endRemoveRows();
-        });
-        emitter->onInitialResultSetComplete([this]() {
-        });
-        emitter->onComplete([this, id]() {
-            mEmitter[id].clear();
-        });
-        emitter->onClear([this]() {
-            // beginResetModel();
-            // mEntities.clear();
-            // endResetModel();
-        });
-        mEmitter.insert(id, emitter);
-        // endResetModel();
+        Trace() << "Loading entities";
+        loadEntities(parentIdentifier);
+    }
+
+    void setFetcher(const std::function<void(const QByteArray &parent)> &fetcher)
+    {
+        Trace() << "Setting fetcher";
+        loadEntities = fetcher;
     }
 
 private:
-    QMap<qint64 /* parent entity id */, QSharedPointer<Akonadi2::ResultEmitter<typename T::Ptr> >> mEmitter;
     //TODO we should be able to directly use T as index, with an appropriate hash function, and thus have a QMap<T, T> and QList<T>
-    QMap<qint64 /* entity id */, typename T::Ptr> mEntities;
+    QMap<qint64 /* entity id */, Ptr> mEntities;
     QMap<qint64 /* parent entity id */, QList<qint64> /* child entity id*/> mTree;
     QMap<qint64 /* child entity id */, qint64 /* parent entity id*/> mParents;
     QMap<qint64 /* entity id */, bool> mEntityChildrenFetched;
     QList<QByteArray> mPropertyColumns;
     Akonadi2::Query mQuery;
+    std::function<void(const QByteArray &)> loadEntities;
 };
 
diff --git a/common/resourcefacade.cpp b/common/resourcefacade.cpp
index 54185f8..0b7c5a3 100644
--- a/common/resourcefacade.cpp
+++ b/common/resourcefacade.cpp
@@ -54,7 +54,7 @@ KAsync::Job<void> ResourceFacade::remove(const Akonadi2::ApplicationDomain::Akon
     });
 }
 
-KAsync::Job<void> ResourceFacade::load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename Akonadi2::ApplicationDomain::AkonadiResource::Ptr> > &resultProvider)
+KAsync::Job<void> ResourceFacade::load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProviderInterface<typename Akonadi2::ApplicationDomain::AkonadiResource::Ptr> > &resultProvider)
 {
     return KAsync::start<void>([query, resultProvider]() {
         const auto configuredResources = ResourceConfig::getResources();
diff --git a/common/resourcefacade.h b/common/resourcefacade.h
index 437ff75..850d380 100644
--- a/common/resourcefacade.h
+++ b/common/resourcefacade.h
@@ -37,5 +37,5 @@ public:
     KAsync::Job<void> create(const Akonadi2::ApplicationDomain::AkonadiResource &resource) Q_DECL_OVERRIDE;
     KAsync::Job<void> modify(const Akonadi2::ApplicationDomain::AkonadiResource &resource) Q_DECL_OVERRIDE;
     KAsync::Job<void> remove(const Akonadi2::ApplicationDomain::AkonadiResource &resource) Q_DECL_OVERRIDE;
-    KAsync::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename Akonadi2::ApplicationDomain::AkonadiResource::Ptr> > &resultProvider) Q_DECL_OVERRIDE;
+    KAsync::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProviderInterface<typename Akonadi2::ApplicationDomain::AkonadiResource::Ptr> > &resultProvider) Q_DECL_OVERRIDE;
 };
diff --git a/common/resultprovider.h b/common/resultprovider.h
index bc03152..43d21a4 100644
--- a/common/resultprovider.h
+++ b/common/resultprovider.h
@@ -34,11 +34,312 @@ namespace Akonadi2 {
 template<class T>
 class ResultEmitter;
 
+template<class T>
+class ResultProviderInterface
+{
+public:
+    ResultProviderInterface()
+        : mRevision(0)
+    {
+
+    }
+
+    virtual void add(const T &value) = 0;
+    virtual void modify(const T &value) = 0;
+    virtual void remove(const T &value) = 0;
+    virtual void initialResultSetComplete() = 0;
+    virtual void complete() = 0;
+    virtual void clear() = 0;
+    virtual void setFetcher(const std::function<void(const QByteArray &parent)> &fetcher)
+    {
+    }
+
+    virtual void setFacade(const std::shared_ptr<void> &facade) = 0;
+    virtual void setQueryRunner(const QSharedPointer<QObject> &runner) = 0;
+
+    void setRevision(qint64 revision)
+    {
+        mRevision = revision;
+    }
+
+    qint64 revision() const
+    {
+        return mRevision;
+    }
+
+private:
+    qint64 mRevision;
+};
+
+template<class T, class Ptr>
+class ModelResultProvider : public ResultProviderInterface<Ptr> {
+public:
+    ModelResultProvider(QWeakPointer<ModelResult<T, Ptr> > model)
+        : ResultProviderInterface<Ptr>(),
+        mModel(model)
+    {
+
+    }
+
+    void add(const Ptr &value)
+    {
+        if (auto model = mModel.toStrongRef()) {
+            model->add(value);
+        }
+    }
+
+    void modify(const Ptr &value)
+    {
+        if (auto model = mModel.toStrongRef()) {
+            model->modify(value);
+        }
+    }
+
+    void remove(const Ptr &value)
+    {
+        if (auto model = mModel.toStrongRef()) {
+            model->remove(value);
+        }
+    }
+
+    void initialResultSetComplete()
+    {
+        // mResultEmitter->initialResultSetComplete();
+    }
+
+    void complete()
+    {
+        // mResultEmitter->complete();
+    }
+
+    void clear()
+    {
+        // mResultEmitter->clear();
+    }
+
+    // QSharedPointer<ResultEmitter<T> > emitter()
+    // {
+    //     if (!mResultEmitter) {
+    //         //We have to go over a separate var and return that, otherwise we'd delete the emitter immediately again
+    //         auto sharedPtr = QSharedPointer<ResultEmitter<T> >(new ResultEmitter<T>, [this](ResultEmitter<T> *emitter){ done(); delete emitter; });
+    //         mResultEmitter = sharedPtr;
+    //         return sharedPtr;
+    //     }
+    //
+    //     return mResultEmitter.toStrongRef();
+    // }
+
+    /**
+     * For lifetimemanagement only.
+     * We keep the runner alive as long as the result provider exists.
+     */
+    void setFacade(const std::shared_ptr<void> &facade)
+    {
+        mFacade = facade;
+    }
+
+    void onDone(const std::function<void()> &callback)
+    {
+        mOnDoneCallback = callback;
+    }
+
+    bool isDone() const
+    {
+        //The existance of the emitter currently defines wether we're done or not.
+        // return mResultEmitter.toStrongRef().isNull();
+        return true;
+    }
+
+    void setFetcher(const std::function<void(const QByteArray &parent)> &fetcher)
+    {
+        if (auto model = mModel.toStrongRef()) {
+            model->setFetcher(fetcher);
+        }
+    }
+
+    void setQueryRunner(const QSharedPointer<QObject> &runner)
+    {
+        mQueryRunner = runner;
+    }
+
+    // qint64 fetch(const ResultSet &resultSet)
+    // {
+    //     //Fetch a bunch
+    //     //
+    //     // Akonadi2::Storage storage(Akonadi2::storageLocation(), mResourceInstanceIdentifier);
+    //     // storage.setDefaultErrorHandler([](const Akonadi2::Storage::Error &error) {
+    //     //     Warning() << "Error during query: " << error.store << error.message;
+    //     // });
+    //     //
+    //     // auto transaction = storage.createTransaction(Akonadi2::Storage::ReadOnly);
+    //
+    //     // Log() << "Querying" << baseRevision << Akonadi2::Storage::maxRevision(transaction);
+    //     // auto resultSet = getResultSet(query, transaction, baseRevision);
+    //     while (resultSet.next([this](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &value, Akonadi2::Operation operation) -> bool {
+    //         switch (operation) {
+    //         case Akonadi2::Operation_Creation:
+    //             Trace() << "Got creation";
+    //             //TODO Only copy in result provider
+    //             add(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<T>(*value).template staticCast<T>());
+    //             break;
+    //         case Akonadi2::Operation_Modification:
+    //             Trace() << "Got modification";
+    //             modify(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<T>(*value).template staticCast<T>());
+    //             break;
+    //         case Akonadi2::Operation_Removal:
+    //             Trace() << "Got removal";
+    //             remove(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<T>(*value).template staticCast<T>());
+    //             break;
+    //         }
+    //         return true;
+    //     })){};
+    //     // return Akonadi2::Storage::maxRevision(transaction);
+    // }
+
+private:
+    void done()
+    {
+        qWarning() << "done";
+        if (mOnDoneCallback) {
+            mOnDoneCallback();
+            mOnDoneCallback = std::function<void()>();
+        }
+    }
+
+    QWeakPointer<ModelResult<T, Ptr> > mModel;
+    QSharedPointer<QObject> mQueryRunner;
+    std::shared_ptr<void> mFacade;
+    std::function<void()> mOnDoneCallback;
+};
+
+
+
+
+
+
+template<class T>
+class SyncResultProvider : public ResultProviderInterface<T> {
+public:
+    void add(const T &value)
+    {
+        mResultEmitter->addHandler(value);
+    }
+
+    void modify(const T &value)
+    {
+        mResultEmitter->modifyHandler(value);
+    }
+
+    void remove(const T &value)
+    {
+        mResultEmitter->removeHandler(value);
+    }
+
+    void initialResultSetComplete()
+    {
+        mResultEmitter->initialResultSetComplete();
+    }
+
+    void complete()
+    {
+        mResultEmitter->complete();
+    }
+
+    void clear()
+    {
+        mResultEmitter->clear();
+    }
+
+    QSharedPointer<ResultEmitter<T> > emitter()
+    {
+        if (!mResultEmitter) {
+            //We have to go over a separate var and return that, otherwise we'd delete the emitter immediately again
+            auto sharedPtr = QSharedPointer<ResultEmitter<T> >(new ResultEmitter<T>, [this](ResultEmitter<T> *emitter){ done(); delete emitter; });
+            mResultEmitter = sharedPtr;
+            return sharedPtr;
+        }
+
+        return mResultEmitter.toStrongRef();
+    }
+
+    /**
+     * For lifetimemanagement only.
+     * We keep the runner alive as long as the result provider exists.
+     */
+    void setFacade(const std::shared_ptr<void> &facade)
+    {
+        mFacade = facade;
+    }
+
+    void onDone(const std::function<void()> &callback)
+    {
+        mOnDoneCallback = callback;
+    }
+
+    bool isDone() const
+    {
+        //The existance of the emitter currently defines wether we're done or not.
+        return mResultEmitter.toStrongRef().isNull();
+    }
+
+    // qint64 fetch(const ResultSet &resultSet)
+    // {
+    //     //Fetch a bunch
+    //     //
+    //     // Akonadi2::Storage storage(Akonadi2::storageLocation(), mResourceInstanceIdentifier);
+    //     // storage.setDefaultErrorHandler([](const Akonadi2::Storage::Error &error) {
+    //     //     Warning() << "Error during query: " << error.store << error.message;
+    //     // });
+    //     //
+    //     // auto transaction = storage.createTransaction(Akonadi2::Storage::ReadOnly);
+    //
+    //     // Log() << "Querying" << baseRevision << Akonadi2::Storage::maxRevision(transaction);
+    //     // auto resultSet = getResultSet(query, transaction, baseRevision);
+    //     while (resultSet.next([this](const Akonadi2::ApplicationDomain::ApplicationDomainType::Ptr &value, Akonadi2::Operation operation) -> bool {
+    //         switch (operation) {
+    //         case Akonadi2::Operation_Creation:
+    //             Trace() << "Got creation";
+    //             //TODO Only copy in result provider
+    //             add(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<T>(*value).template staticCast<T>());
+    //             break;
+    //         case Akonadi2::Operation_Modification:
+    //             Trace() << "Got modification";
+    //             modify(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<T>(*value).template staticCast<T>());
+    //             break;
+    //         case Akonadi2::Operation_Removal:
+    //             Trace() << "Got removal";
+    //             remove(Akonadi2::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<T>(*value).template staticCast<T>());
+    //             break;
+    //         }
+    //         return true;
+    //     })){};
+    //     // return Akonadi2::Storage::maxRevision(transaction);
+    // }
+
+private:
+    void done()
+    {
+        qWarning() << "done";
+        if (mOnDoneCallback) {
+            mOnDoneCallback();
+            mOnDoneCallback = std::function<void()>();
+        }
+    }
+
+    QWeakPointer<ResultEmitter<T> > mResultEmitter;
+    std::shared_ptr<void> mFacade;
+    std::function<void()> mOnDoneCallback;
+    QSharedPointer<ThreadBoundary> mThreadBoundary;
+};
+
+
+
+
 /*
 * The promise side for the result emitter
 */
 template<class T>
-class ResultProvider {
+class ResultProvider : public ResultProviderInterface<T> {
 private:
     void callInMainThreadOnEmitter(void (ResultEmitter<T>::*f)())
     {
diff --git a/examples/dummyresource/resourcefacade.cpp b/examples/dummyresource/resourcefacade.cpp
index df805e4..1090757 100644
--- a/examples/dummyresource/resourcefacade.cpp
+++ b/examples/dummyresource/resourcefacade.cpp
@@ -65,7 +65,7 @@ KAsync::Job<void> DummyResourceConfigFacade::remove(const Akonadi2::ApplicationD
     return KAsync::null<void>();
 }
 
-KAsync::Job<void> DummyResourceConfigFacade::load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename Akonadi2::ApplicationDomain::AkonadiResource::Ptr> > &resultProvider)
+KAsync::Job<void> DummyResourceConfigFacade::load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProviderInterface<typename Akonadi2::ApplicationDomain::AkonadiResource::Ptr> > &resultProvider)
 {
     //Read configuration and list all available instances.
     //This includes runtime information about runing instances etc.
diff --git a/examples/dummyresource/resourcefacade.h b/examples/dummyresource/resourcefacade.h
index 5a5f46b..aa2ab05 100644
--- a/examples/dummyresource/resourcefacade.h
+++ b/examples/dummyresource/resourcefacade.h
@@ -42,7 +42,7 @@ public:
     //Remove instance
     KAsync::Job<void> remove(const Akonadi2::ApplicationDomain::AkonadiResource &domainObject) Q_DECL_OVERRIDE;
     //Read configuration and available instances
-    KAsync::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename Akonadi2::ApplicationDomain::AkonadiResource::Ptr> > &resultProvider) Q_DECL_OVERRIDE;
+    KAsync::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProviderInterface<typename Akonadi2::ApplicationDomain::AkonadiResource::Ptr> > &resultProvider) Q_DECL_OVERRIDE;
 
 private:
     QSharedPointer<QSettings> getSettings();
diff --git a/tests/clientapitest.cpp b/tests/clientapitest.cpp
index 5bfad4b..2b3cc46 100644
--- a/tests/clientapitest.cpp
+++ b/tests/clientapitest.cpp
@@ -27,7 +27,7 @@ public:
     KAsync::Job<void> create(const T &domainObject) Q_DECL_OVERRIDE { return KAsync::null<void>(); };
     KAsync::Job<void> modify(const T &domainObject) Q_DECL_OVERRIDE { return KAsync::null<void>(); };
     KAsync::Job<void> remove(const T &domainObject) Q_DECL_OVERRIDE { return KAsync::null<void>(); };
-    KAsync::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProvider<typename T::Ptr> > &resultProvider) Q_DECL_OVERRIDE
+    KAsync::Job<void> load(const Akonadi2::Query &query, const QSharedPointer<Akonadi2::ResultProviderInterface<typename T::Ptr> > &resultProvider) Q_DECL_OVERRIDE
     {
         capturedResultProvider = resultProvider;
         return KAsync::start<void>([this, resultProvider, query]() {
@@ -41,7 +41,7 @@ public:
     }
 
     QList<typename T::Ptr> results;
-    QWeakPointer<Akonadi2::ResultProvider<typename T::Ptr> > capturedResultProvider;
+    QWeakPointer<Akonadi2::ResultProviderInterface<typename T::Ptr> > capturedResultProvider;
 };