Move implementations to the cpp file.

I finally figured out how to do that with cpp files.
It requires instantiating the code with all expected classes,
but that's not a big problem since we know all types.

This will hopefully greatly reduce the compiletimes...

6 files changed, 400 insertions, 254 deletions

diff --git a/common/clientapi.cpp b/common/clientapi.cpp
index 839e77b..02f8ce6 100644
--- a/common/clientapi.cpp
+++ b/common/clientapi.cpp
@@ -1,13 +1,40 @@
+/*
+ * Copyright (C) 2014 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
 
 #include "clientapi.h"
+
+#include <QtConcurrent/QtConcurrentRun>
+#include <QTimer>
+#include <QEventLoop>
+#include <QAbstractItemModel>
+#include <functional>
+#include <memory>
+
 #include "resourceaccess.h"
 #include "commands.h"
 #include "resourcefacade.h"
 #include "log.h"
 #include "definitions.h"
 #include "resourceconfig.h"
-#include <QtConcurrent/QtConcurrentRun>
-#include <QTimer>
+#include "facadefactory.h"
+#include "log.h"
 
 #define ASYNCINTHREAD
 
@@ -69,6 +96,114 @@ QList<QByteArray> Store::getResources(const QList<QByteArray> &resourceFilter, c
     return resources;
 }
 
+template <class DomainType>
+QSharedPointer<ResultEmitter<typename DomainType::Ptr> > Store::load(Query query)
+{
+    auto resultSet = QSharedPointer<ResultProvider<typename DomainType::Ptr> >::create();
+
+    //Execute the search in a thread.
+    //We must guarantee that the emitter is returned before the first result is emitted.
+    //The result provider must be threadsafe.
+    async::run([query, resultSet](){
+        QEventLoop eventLoop;
+        resultSet->onDone([&eventLoop](){
+            eventLoop.quit();
+        });
+        // Query all resources and aggregate results
+        KAsync::iterate(getResources(query.resources, ApplicationDomain::getTypeName<DomainType>()))
+        .template each<void, QByteArray>([query, resultSet](const QByteArray &resource, KAsync::Future<void> &future) {
+            if (auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceName(resource), resource)) {
+                facade->load(query, *resultSet).template then<void>([&future](){future.setFinished();}).exec();
+                //Keep the facade alive for the lifetime of the resultSet.
+                resultSet->setFacade(facade);
+            } else {
+                //Ignore the error and carry on
+                future.setFinished();
+            }
+        }).template then<void>([query, resultSet]() {
+            resultSet->initialResultSetComplete();
+            if (!query.liveQuery) {
+                resultSet->complete();
+            }
+        }).exec();
+
+        //Keep the thread alive until the result is ready
+        if (!resultSet->isDone()) {
+            eventLoop.exec();
+        }
+    });
+    return resultSet->emitter();
+}
+
+template <class DomainType>
+QSharedPointer<QAbstractItemModel> Store::loadModel(Query query)
+{
+    auto model = QSharedPointer<ModelResult<DomainType, typename DomainType::Ptr> >::create(query, query.requestedProperties.toList());
+    auto resultProvider = std::make_shared<ModelResultProvider<DomainType, typename DomainType::Ptr> >(model);
+    //Keep the resultprovider alive for as long as the model lives
+    model->setProperty("resultProvider", QVariant::fromValue(std::shared_ptr<void>(resultProvider)));
+
+    // 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.
+            //FIXME this would have to become a list
+            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)
+{
+    if (auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceName(resourceInstanceIdentifier), resourceInstanceIdentifier)) {
+        return facade;
+    }
+    return std::make_shared<NullFacade<DomainType> >();
+}
+
+template <class DomainType>
+KAsync::Job<void> Store::create(const DomainType &domainObject) {
+    //Potentially move to separate thread as well
+    auto facade = getFacade<DomainType>(domainObject.resourceInstanceIdentifier());
+    return facade->create(domainObject).template then<void>([facade](){}, [](int errorCode, const QString &error) {
+        Warning() << "Failed to create";
+    });
+}
+
+template <class DomainType>
+KAsync::Job<void> Store::modify(const DomainType &domainObject)
+{
+    //Potentially move to separate thread as well
+    auto facade = getFacade<DomainType>(domainObject.resourceInstanceIdentifier());
+    return facade->modify(domainObject).template then<void>([facade](){}, [](int errorCode, const QString &error) {
+        Warning() << "Failed to modify";
+    });
+}
+
+template <class DomainType>
+KAsync::Job<void> Store::remove(const DomainType &domainObject)
+{
+    //Potentially move to separate thread as well
+    auto facade = getFacade<DomainType>(domainObject.resourceInstanceIdentifier());
+    return facade->remove(domainObject).template then<void>([facade](){}, [](int errorCode, const QString &error) {
+        Warning() << "Failed to remove";
+    });
+}
+
 KAsync::Job<void> Store::shutdown(const QByteArray &identifier)
 {
     Trace() << "shutdown";
@@ -103,4 +238,16 @@ KAsync::Job<void> Store::synchronize(const Akonadi2::Query &query)
     .template then<void>([](){});
 }
 
+#define REGISTER_TYPE(T) template KAsync::Job<void> Store::remove<T>(const T &domainObject); \
+    template KAsync::Job<void> Store::create<T>(const T &domainObject); \
+    template KAsync::Job<void> Store::modify<T>(const T &domainObject); \
+    template QSharedPointer<ResultEmitter<typename T::Ptr> > Store::load<T>(Query query); \
+    template QSharedPointer<QAbstractItemModel> Store::loadModel<T>(Query query); \
+
+REGISTER_TYPE(ApplicationDomain::Event);
+REGISTER_TYPE(ApplicationDomain::Mail);
+REGISTER_TYPE(ApplicationDomain::Folder);
+REGISTER_TYPE(ApplicationDomain::AkonadiResource);
+
 } // namespace Akonadi2
+
diff --git a/common/clientapi.h b/common/clientapi.h
index 6b11ad5..c48c6e9 100644
--- a/common/clientapi.h
+++ b/common/clientapi.h
@@ -22,21 +22,17 @@
 
 #include <QString>
 #include <QSharedPointer>
-#include <QEventLoop>
-#include <QAbstractItemModel>
-#include <functional>
-#include <memory>
 
 #include <Async/Async>
 
 #include "query.h"
 #include "resultprovider.h"
 #include "applicationdomaintype.h"
-#include "facadefactory.h"
-#include "log.h"
 
 Q_DECLARE_METATYPE(std::shared_ptr<void>);
 
+class QAbstractItemModel;
+
 namespace async {
     //This should abstract if we execute from eventloop or in thread.
     //It supposed to allow the caller to finish the current method before executing the runner.
@@ -62,43 +58,7 @@ public:
      * Asynchronusly load a dataset
      */
     template <class DomainType>
-    static QSharedPointer<ResultEmitter<typename DomainType::Ptr> > load(Query query)
-    {
-        auto resultSet = QSharedPointer<ResultProvider<typename DomainType::Ptr> >::create();
-
-        //Execute the search in a thread.
-        //We must guarantee that the emitter is returned before the first result is emitted.
-        //The result provider must be threadsafe.
-        async::run([query, resultSet](){
-            QEventLoop eventLoop;
-            resultSet->onDone([&eventLoop](){
-                eventLoop.quit();
-            });
-            // Query all resources and aggregate results
-            KAsync::iterate(getResources(query.resources, ApplicationDomain::getTypeName<DomainType>()))
-            .template each<void, QByteArray>([query, resultSet](const QByteArray &resource, KAsync::Future<void> &future) {
-                if (auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceName(resource), resource)) {
-                    facade->load(query, *resultSet).template then<void>([&future](){future.setFinished();}).exec();
-                    //Keep the facade alive for the lifetime of the resultSet.
-                    resultSet->setFacade(facade);
-                } else {
-                    //Ignore the error and carry on
-                    future.setFinished();
-                }
-            }).template then<void>([query, resultSet]() {
-                resultSet->initialResultSetComplete();
-                if (!query.liveQuery) {
-                    resultSet->complete();
-                }
-            }).exec();
-
-            //Keep the thread alive until the result is ready
-            if (!resultSet->isDone()) {
-                eventLoop.exec();
-            }
-        });
-        return resultSet->emitter();
-    }
+    static QSharedPointer<ResultEmitter<typename DomainType::Ptr> > load(Query query);
 
     enum Roles {
         DomainObjectRole = Qt::UserRole + 1 //Must be the same as in ModelResult
@@ -108,56 +68,13 @@ public:
      * Asynchronusly load a dataset with tree structure information
      */
     template <class DomainType>
-    static QSharedPointer<QAbstractItemModel> loadModel(Query query)
-    {
-        auto model = QSharedPointer<ModelResult<DomainType, typename DomainType::Ptr> >::create(query, query.requestedProperties.toList());
-        auto resultProvider = std::make_shared<ModelResultProvider<DomainType, typename DomainType::Ptr> >(model);
-        //Keep the resultprovider alive for as long as the model lives
-        model->setProperty("resultProvider", QVariant::fromValue(std::shared_ptr<void>(resultProvider)));
-
-        // 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.
-                //FIXME this would have to become a list
-                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)
-    {
-        if (auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceName(resourceInstanceIdentifier), resourceInstanceIdentifier)) {
-            return facade;
-        }
-        return std::make_shared<NullFacade<DomainType> >();
-    }
+    static QSharedPointer<QAbstractItemModel> loadModel(Query query);
 
     /**
      * Create a new entity.
      */
     template <class DomainType>
-    static KAsync::Job<void> create(const DomainType &domainObject) {
-        //Potentially move to separate thread as well
-        auto facade = getFacade<DomainType>(domainObject.resourceInstanceIdentifier());
-        return facade->create(domainObject).template then<void>([facade](){}, [](int errorCode, const QString &error) {
-            Warning() << "Failed to create";
-        });
-    }
+    static KAsync::Job<void> create(const DomainType &domainObject);
 
     /**
      * Modify an entity.
@@ -165,25 +82,13 @@ public:
      * This includes moving etc. since these are also simple settings on a property.
      */
     template <class DomainType>
-    static KAsync::Job<void> modify(const DomainType &domainObject) {
-        //Potentially move to separate thread as well
-        auto facade = getFacade<DomainType>(domainObject.resourceInstanceIdentifier());
-        return facade->modify(domainObject).template then<void>([facade](){}, [](int errorCode, const QString &error) {
-            Warning() << "Failed to modify";
-        });
-    }
+    static KAsync::Job<void> modify(const DomainType &domainObject);
 
     /**
      * Remove an entity.
      */
     template <class DomainType>
-    static KAsync::Job<void> remove(const DomainType &domainObject) {
-        //Potentially move to separate thread as well
-        auto facade = getFacade<DomainType>(domainObject.resourceInstanceIdentifier());
-        return facade->remove(domainObject).template then<void>([facade](){}, [](int errorCode, const QString &error) {
-            Warning() << "Failed to remove";
-        });
-    }
+    static KAsync::Job<void> remove(const DomainType &domainObject);
 
     /**
      * Shutdown resource.
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index b4cf8c4..227ab4d 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -162,3 +162,5 @@ Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::Mail)
 Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::Mail::Ptr)
 Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::Folder)
 Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::Folder::Ptr)
+Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::AkonadiResource)
+Q_DECLARE_METATYPE(Akonadi2::ApplicationDomain::AkonadiResource::Ptr)
diff --git a/common/modelresult.cpp b/common/modelresult.cpp
new file mode 100644
index 0000000..1abcc62
--- /dev/null
+++ b/common/modelresult.cpp
@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2014 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) version 3, or any
+ * later version accepted by the membership of KDE e.V. (or its
+ * successor approved by the membership of KDE e.V.), which shall
+ * act as a proxy defined in Section 6 of version 3 of the license.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "modelresult.h"
+
+#include <QDebug>
+
+#include "domain/folder.h"
+#include "log.h"
+
+template<class T, class Ptr>
+ModelResult<T, Ptr>::ModelResult(const Akonadi2::Query &query, const QList<QByteArray> &propertyColumns)
+    :QAbstractItemModel(),
+    mPropertyColumns(propertyColumns)
+{
+}
+
+static qint64 getIdentifier(const QModelIndex &idx)
+{
+    if (!idx.isValid()) {
+        return 0;
+    }
+    return idx.internalId();
+}
+
+template<class T, class Ptr>
+qint64 ModelResult<T, Ptr>::parentId(const Ptr &value)
+{
+    return qHash(value->getProperty("parent").toByteArray());
+}
+
+template<class T, class Ptr>
+int ModelResult<T, Ptr>::rowCount(const QModelIndex &parent) const
+{
+    return mTree[getIdentifier(parent)].size();
+}
+
+template<class T, class Ptr>
+int ModelResult<T, Ptr>::columnCount(const QModelIndex &parent) const
+{
+    return mPropertyColumns.size();
+}
+
+template<class T, class Ptr>
+QVariant ModelResult<T, Ptr>::data(const QModelIndex &index, int role) const
+{
+    if (role == DomainObjectRole) {
+        Q_ASSERT(mEntities.contains(index.internalId()));
+        return QVariant::fromValue(mEntities.value(index.internalId()));
+    }
+    if (role == Qt::DisplayRole) {
+        if (index.column() < mPropertyColumns.size()) {
+            Q_ASSERT(mEntities.contains(index.internalId()));
+            auto entity = mEntities.value(index.internalId());
+            return entity->getProperty(mPropertyColumns.at(index.column())).toString();
+        } else {
+            return "No data available";
+        }
+    }
+    return QVariant();
+}
+
+template<class T, class Ptr>
+QModelIndex ModelResult<T, Ptr>::index(int row, int column, const QModelIndex &parent) const
+{
+    auto id = getIdentifier(parent);
+    auto childId = mTree.value(id).at(row);
+    return createIndex(row, column, childId);
+}
+
+template<class T, class Ptr>
+QModelIndex ModelResult<T, Ptr>::createIndexFromId(const qint64 &id) const
+{
+    auto grandParentId = mParents.value(id, 0);
+    auto row = mTree.value(grandParentId).indexOf(id);
+    return createIndex(row, 0, id);
+}
+
+template<class T, class Ptr>
+QModelIndex ModelResult<T, Ptr>::parent(const QModelIndex &index) const
+{
+    auto id = getIdentifier(index);
+    auto parentId = mParents.value(id);
+    return createIndexFromId(parentId);
+}
+
+template<class T, class Ptr>
+bool ModelResult<T, Ptr>::canFetchMore(const QModelIndex &parent) const
+{
+    qDebug() << "Can fetch more: " << parent << mEntityChildrenFetched.value(parent.internalId());
+    return mEntityChildrenFetched.value(parent.internalId());
+}
+
+template<class T, class Ptr>
+void ModelResult<T, Ptr>::fetchMore(const QModelIndex &parent)
+{
+    qDebug() << "Fetch more: " << parent;
+    fetchEntities(parent);
+}
+
+template<class T, class Ptr>
+void ModelResult<T, Ptr>::add(const Ptr &value)
+{
+    auto childId = qHash(value->identifier());
+    auto id = parentId(value);
+    //Ignore updates we get before the initial fetch is done
+    if (!mEntityChildrenFetched[id]) {
+        return;
+    }
+    auto parent = createIndexFromId(id);
+    qDebug() << "Added entity " << childId << value->identifier() << id;
+    const auto keys = mTree[id];
+    int index = 0;
+    for (; index < keys.size(); index++) {
+        if (childId < keys.at(index)) {
+            break;
+        }
+    }
+    if (mEntities.contains(childId)) {
+        qWarning() << "Entity already in model " << value->identifier();
+        return;
+    }
+    qDebug() << "Inserting rows " << index << parent;
+    beginInsertRows(QModelIndex(), index, index);
+    mEntities.insert(childId, value);
+    mTree[id].insert(index, childId);
+    mParents.insert(childId, id);
+    endInsertRows();
+    qDebug() << "Inserted rows " << mTree[id].size();
+}
+
+
+template<class T, class Ptr>
+void ModelResult<T, Ptr>::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();
+}
+
+template<class T, class Ptr>
+void ModelResult<T, Ptr>::fetchEntities(const QModelIndex &parent)
+{
+    const auto id = getIdentifier(parent);
+    mEntityChildrenFetched[id] = true;
+    Trace() << "Loading child entities";
+    loadEntities(parent.data(DomainObjectRole).template value<Ptr>());
+}
+
+template<class T, class Ptr>
+void ModelResult<T, Ptr>::setFetcher(const std::function<void(const Ptr &parent)> &fetcher)
+{
+    Trace() << "Setting fetcher";
+    loadEntities = fetcher;
+}
+
+template<class T, class Ptr>
+void ModelResult<T, Ptr>::modify(const Ptr &value)
+{
+    auto childId = qHash(value->identifier());
+    auto id = parentId(value);
+    //Ignore updates we get before the initial fetch is done
+    if (!mEntityChildrenFetched[id]) {
+        return;
+    }
+    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);
+}
+
+template class ModelResult<Akonadi2::ApplicationDomain::Folder, Akonadi2::ApplicationDomain::Folder::Ptr>;
+template class ModelResult<Akonadi2::ApplicationDomain::Mail, Akonadi2::ApplicationDomain::Mail::Ptr>;
+template class ModelResult<Akonadi2::ApplicationDomain::Event, Akonadi2::ApplicationDomain::Event::Ptr>;
+template class ModelResult<Akonadi2::ApplicationDomain::AkonadiResource, Akonadi2::ApplicationDomain::AkonadiResource::Ptr>;
diff --git a/common/modelresult.h b/common/modelresult.h
index 26f96d8..40a9d9d 100644
--- a/common/modelresult.h
+++ b/common/modelresult.h
@@ -23,10 +23,9 @@
 #include <QAbstractItemModel>
 #include <QModelIndex>
 #include <QDebug>
+#include <functional>
 #include "query.h"
 
-#include "resultprovider.h"
-
 template<class T, class Ptr>
 class ModelResult : public QAbstractItemModel
 {
@@ -36,160 +35,28 @@ public:
         DomainObjectRole = Qt::UserRole + 1
     };
 
-    ModelResult(const Akonadi2::Query &query, const QList<QByteArray> &propertyColumns)
-        :QAbstractItemModel(),
-        mPropertyColumns(propertyColumns)
-    {
-    }
-
-    static qint64 getIdentifier(const QModelIndex &idx)
-    {
-        if (!idx.isValid()) {
-            return 0;
-        }
-        return idx.internalId();
-    }
-
-    int rowCount(const QModelIndex &parent = QModelIndex()) const
-    {
-        return mTree[getIdentifier(parent)].size();
-    }
-
-    int columnCount(const QModelIndex &parent = QModelIndex()) const
-    {
-        return mPropertyColumns.size();
-    }
-
-    virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const
-    {
-        if (role == DomainObjectRole) {
-            Q_ASSERT(mEntities.contains(index.internalId()));
-            return QVariant::fromValue(mEntities.value(index.internalId()));
-        }
-        if (role == Qt::DisplayRole) {
-            if (index.column() < mPropertyColumns.size()) {
-                Q_ASSERT(mEntities.contains(index.internalId()));
-                auto entity = mEntities.value(index.internalId());
-                return entity->getProperty(mPropertyColumns.at(index.column())).toString();
-            } else {
-                return "No data available";
-            }
-        }
-        return QVariant();
-    }
-
-    QModelIndex index(int row, int column, const QModelIndex & parent = QModelIndex()) const
-    {
-        auto id = getIdentifier(parent);
-        auto childId = mTree.value(id).at(row);
-        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);
-    }
+    ModelResult(const Akonadi2::Query &query, const QList<QByteArray> &propertyColumns);
 
-    QModelIndex parent(const QModelIndex &index) const
-    {
-        auto id = getIdentifier(index);
-        auto parentId = mParents.value(id);
-        return createIndexFromId(parentId);
-    }
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    QModelIndex index(int row, int column, const QModelIndex & parent = QModelIndex()) const;
+    QModelIndex parent(const QModelIndex &index) const;
 
-    bool canFetchMore(const QModelIndex &parent) const
-    {
-        return mEntityChildrenFetched.value(parent.internalId());
-    }
+    bool canFetchMore(const QModelIndex &parent) const;
+    void fetchMore(const QModelIndex &parent);
 
-    void fetchMore(const QModelIndex &parent)
-    {
-        fetchEntities(parent);
-    }
+    void add(const Ptr &value);
+    void modify(const Ptr &value);
+    void remove(const Ptr &value);
 
-    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);
-        //Ignore updates we get before the initial fetch is done
-        if (!mEntityChildrenFetched[id]) {
-            return;
-        }
-        auto parent = createIndexFromId(id);
-        qDebug() << "Added entity " << childId << value->identifier();
-        const auto keys = mTree[id];
-        int index = 0;
-        for (; index < keys.size(); index++) {
-            if (childId < keys.at(index)) {
-                break;
-            }
-        }
-        if (mEntities.contains(childId)) {
-            qWarning() << "Entity already in model " << value->identifier();
-            return;
-        }
-        beginInsertRows(QModelIndex(), 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);
-        //Ignore updates we get before the initial fetch is done
-        if (!mEntityChildrenFetched[id]) {
-            return;
-        }
-        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)
-    {
-        const auto id = getIdentifier(parent);
-        mEntityChildrenFetched[id] = true;
-        Trace() << "Loading child entities";
-        loadEntities(parent.data(DomainObjectRole).template value<Ptr>());
-    }
-
-    void setFetcher(const std::function<void(const Ptr &parent)> &fetcher)
-    {
-        Trace() << "Setting fetcher";
-        loadEntities = fetcher;
-    }
+    void setFetcher(const std::function<void(const Ptr &parent)> &fetcher);
 
 private:
+    static qint64 parentId(const Ptr &value);
+    QModelIndex createIndexFromId(const qint64 &id) const;
+    void fetchEntities(const QModelIndex &parent);
+
     //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 */, Ptr> mEntities;
     QMap<qint64 /* parent entity id */, QList<qint64> /* child entity id*/> mTree;
diff --git a/examples/dummyresource/dummystore.cpp b/examples/dummyresource/dummystore.cpp
index 0356ec0..39ecfe4 100644
--- a/examples/dummyresource/dummystore.cpp
+++ b/examples/dummyresource/dummystore.cpp
@@ -36,6 +36,13 @@ static QMap<QString, QVariant> createMail(int i)
     return mail;
 }
 
+static QMap<QString, QVariant> createFolder(int i)
+{
+    QMap<QString, QVariant> folder;
+    folder.insert("name", QString("folder%1").arg(i));
+    return folder;
+}
+
 QMap<QString, QMap<QString, QVariant> > populateEvents()
 {
     QMap<QString, QMap<QString, QVariant>> content;
@@ -54,8 +61,18 @@ QMap<QString, QMap<QString, QVariant> > populateMails()
     return content;
 }
 
+QMap<QString, QMap<QString, QVariant> > populateFolders()
+{
+    QMap<QString, QMap<QString, QVariant>> content;
+    for (int i = 0; i < 5000; i++) {
+        content.insert(QString("key%1").arg(i), createFolder(i));
+    }
+    return content;
+}
+
 static QMap<QString, QMap<QString, QVariant> > s_eventSource = populateEvents();
 static QMap<QString, QMap<QString, QVariant> > s_mailSource = populateMails();
+static QMap<QString, QMap<QString, QVariant> > s_folderSource = populateFolders();
 
 QMap<QString, QMap<QString, QVariant> > DummyStore::events() const
 {
@@ -66,3 +83,8 @@ QMap<QString, QMap<QString, QVariant> > DummyStore::mails() const
 {
     return s_mailSource;
 }
+
+QMap<QString, QMap<QString, QVariant> > DummyStore::folders() const
+{
+    return s_folderSource;
+}