Support result property transformations

This can be used to modify each result before reporting it to the
client. Alternatively this could also be done in the DomainTypeAdaptor,
which would perhaps be the cleaner solution...

4 files changed, 36 insertions, 12 deletions

diff --git a/common/facade.cpp b/common/facade.cpp
index 540c364..1b91ce4 100644
--- a/common/facade.cpp
+++ b/common/facade.cpp
@@ -148,6 +148,7 @@ QPair<KAsync::Job<void>, typename ResultEmitter<typename DomainType::Ptr>::Ptr>
 {
     //The runner lives for the lifetime of the query
     auto runner = new QueryRunner<DomainType>(query, mResourceAccess, mResourceInstanceIdentifier, mDomainTypeAdaptorFactory, bufferTypeForDomainType());
+    runner->setResultTransformation(mResultTransformation);
     return qMakePair(KAsync::null<void>(), runner->emitter());
 }
 
diff --git a/common/facade.h b/common/facade.h
index 71451e2..914b6fc 100644
--- a/common/facade.h
+++ b/common/facade.h
@@ -60,9 +60,10 @@ public:
     KAsync::Job<void> create(const DomainType &domainObject) Q_DECL_OVERRIDE;
     KAsync::Job<void> modify(const DomainType &domainObject) Q_DECL_OVERRIDE;
     KAsync::Job<void> remove(const DomainType &domainObject) Q_DECL_OVERRIDE;
-    QPair<KAsync::Job<void>, typename ResultEmitter<typename DomainType::Ptr>::Ptr> load(const Sink::Query &query) Q_DECL_OVERRIDE;
+    virtual QPair<KAsync::Job<void>, typename ResultEmitter<typename DomainType::Ptr>::Ptr> load(const Sink::Query &query) Q_DECL_OVERRIDE;
 
 protected:
+    std::function<void(Sink::ApplicationDomain::ApplicationDomainType &domainObject)> mResultTransformation;
     //TODO use one resource access instance per application & per resource
     QSharedPointer<Sink::ResourceAccessInterface> mResourceAccess;
     DomainTypeAdaptorFactoryInterface::Ptr mDomainTypeAdaptorFactory;
diff --git a/common/queryrunner.cpp b/common/queryrunner.cpp
index a62c64c..4d05721 100644
--- a/common/queryrunner.cpp
+++ b/common/queryrunner.cpp
@@ -41,14 +41,14 @@ template<typename DomainType>
 class QueryWorker : public QObject
 {
 public:
-    QueryWorker(const Sink::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &, const QByteArray &bufferType);
+    QueryWorker(const Sink::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &, const QByteArray &bufferType, const QueryRunnerBase::ResultTransformation &transformation);
     virtual ~QueryWorker();
 
     qint64 executeIncrementalQuery(const Sink::Query &query, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider);
     qint64 executeInitialQuery(const Sink::Query &query, const typename DomainType::Ptr &parent, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider);
 
 private:
-    static void replaySet(ResultSet &resultSet, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const QList<QByteArray> &properties);
+    void replaySet(ResultSet &resultSet, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const QList<QByteArray> &properties);
 
     void readEntity(const Sink::Storage::NamedDatabase &db, const QByteArray &key, const std::function<void(const Sink::ApplicationDomain::ApplicationDomainType::Ptr &, Sink::Operation)> &resultCallback);
 
@@ -60,6 +60,7 @@ private:
     qint64 load(const Sink::Query &query, const std::function<ResultSet(Sink::Storage::Transaction &, QSet<QByteArray> &)> &baseSetRetriever, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, bool initialQuery);
 
 private:
+    QueryRunnerBase::ResultTransformation mResultTransformation;
     DomainTypeAdaptorFactoryInterface::Ptr mDomainTypeAdaptorFactory;
     QByteArray mResourceInstanceIdentifier;
     QByteArray mBufferType;
@@ -78,8 +79,8 @@ QueryRunner<DomainType>::QueryRunner(const Sink::Query &query, const Sink::Resou
     mResultProvider->setFetcher([=](const typename DomainType::Ptr &parent) {
         Trace() << "Running fetcher";
         auto resultProvider = mResultProvider;
-        async::run<qint64>([query, instanceIdentifier, factory, bufferType, parent, resultProvider]() -> qint64 {
-                QueryWorker<DomainType> worker(query, instanceIdentifier, factory, bufferType);
+        async::run<qint64>([=]() -> qint64 {
+                QueryWorker<DomainType> worker(query, instanceIdentifier, factory, bufferType, mResultTransformation);
                 const qint64 newRevision = worker.executeInitialQuery(query, parent, *resultProvider);
                 return newRevision;
             })
@@ -96,8 +97,8 @@ QueryRunner<DomainType>::QueryRunner(const Sink::Query &query, const Sink::Resou
         //Incremental updates are always loaded directly, leaving it up to the result to discard the changes if they are not interesting
         setQuery([=] () -> KAsync::Job<void> {
             auto resultProvider = mResultProvider;
-                    QueryWorker<DomainType> worker(query, instanceIdentifier, factory, bufferType);
             return async::run<qint64>([=]() -> qint64 {
+                    QueryWorker<DomainType> worker(query, instanceIdentifier, factory, bufferType, mResultTransformation);
                     const qint64 newRevision = worker.executeIncrementalQuery(query, *resultProvider);
                     return newRevision;
                 })
@@ -121,6 +122,12 @@ QueryRunner<DomainType>::~QueryRunner()
 }
 
 template<class DomainType>
+void QueryRunner<DomainType>::setResultTransformation(const ResultTransformation &transformation)
+{
+    mResultTransformation = transformation;
+}
+
+template<class DomainType>
 typename Sink::ResultEmitter<typename DomainType::Ptr>::Ptr QueryRunner<DomainType>::emitter()
 {
     return mResultProvider->emitter();
@@ -150,8 +157,9 @@ static inline ResultSet fullScan(const Sink::Storage::Transaction &transaction,
 
 
 template<class DomainType>
-QueryWorker<DomainType>::QueryWorker(const Sink::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &factory, const QByteArray &bufferType)
+QueryWorker<DomainType>::QueryWorker(const Sink::Query &query, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &factory, const QByteArray &bufferType, const QueryRunnerBase::ResultTransformation &transformation)
     : QObject(),
+    mResultTransformation(transformation),
     mDomainTypeAdaptorFactory(factory),
     mResourceInstanceIdentifier(instanceIdentifier),
     mBufferType(bufferType),
@@ -170,20 +178,25 @@ template<class DomainType>
 void QueryWorker<DomainType>::replaySet(ResultSet &resultSet, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const QList<QByteArray> &properties)
 {
     int counter = 0;
-    while (resultSet.next([&resultProvider, &counter, &properties](const Sink::ApplicationDomain::ApplicationDomainType::Ptr &value, Sink::Operation operation) -> bool {
+    while (resultSet.next([this, &resultProvider, &counter, &properties](const Sink::ApplicationDomain::ApplicationDomainType::Ptr &value, Sink::Operation operation) -> bool {
+        //FIXME allow maildir resource to set the mimeMessage property
+        auto valueCopy = Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>();
+        if (mResultTransformation) {
+            mResultTransformation(*valueCopy);
+        }
         counter++;
         switch (operation) {
         case Sink::Operation_Creation:
             // Trace() << "Got creation";
-            resultProvider.add(Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>());
+            resultProvider.add(valueCopy);
             break;
         case Sink::Operation_Modification:
             // Trace() << "Got modification";
-            resultProvider.modify(Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>());
+            resultProvider.modify(valueCopy);
             break;
         case Sink::Operation_Removal:
             // Trace() << "Got removal";
-            resultProvider.remove(Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(*value, properties).template staticCast<DomainType>());
+            resultProvider.remove(valueCopy);
             break;
         }
         return true;
diff --git a/common/queryrunner.h b/common/queryrunner.h
index 0ee6a81..04e4587 100644
--- a/common/queryrunner.h
+++ b/common/queryrunner.h
@@ -32,6 +32,9 @@
 class QueryRunnerBase : public QObject
 {
     Q_OBJECT
+public:
+    typedef std::function<void(Sink::ApplicationDomain::ApplicationDomainType &domainObject)> ResultTransformation;
+
 protected:
     typedef std::function<KAsync::Job<void>()> QueryFunction;
 
@@ -43,7 +46,6 @@ protected:
         queryFunction = query;
     }
 
-
 protected slots:
     /**
      * Rerun query with new revision
@@ -82,10 +84,17 @@ public:
     QueryRunner(const Sink::Query &query, const Sink::ResourceAccessInterface::Ptr &, const QByteArray &instanceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &, const QByteArray &bufferType);
     virtual ~QueryRunner();
 
+    /**
+     * Allows you to run a transformation on every result.
+     * This transformation is executed in the query thread.
+     */
+    void setResultTransformation(const ResultTransformation &transformation);
+
     typename Sink::ResultEmitter<typename DomainType::Ptr>::Ptr emitter();
 
 private:
     QSharedPointer<Sink::ResourceAccessInterface> mResourceAccess;
     QSharedPointer<Sink::ResultProvider<typename DomainType::Ptr> > mResultProvider;
+    ResultTransformation mResultTransformation;
 };