Use the ApplicationDomainType in the queries as well.

We have to access properties, so we need the mapper anyways, and the
ApplicationDomainType type shouldn't be a large overhead anyways.

12 files changed, 66 insertions, 125 deletions

diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index 8897c29..f56ac91 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -19,8 +19,6 @@
 #include "datastorequery.h"
 
 #include "log.h"
-#include "entitybuffer.h"
-#include "entity_generated.h"
 #include "applicationdomaintype.h"
 
 #include "folder.h"
@@ -68,8 +66,8 @@ class Source : public FilterBase {
         if (mIt == mIds.constEnd()) {
             return false;
         }
-        readEntity(*mIt, [callback](const QByteArray &uid, const Sink::EntityBuffer &entityBuffer) {
-            callback({uid, entityBuffer, entityBuffer.operation()});
+        readEntity(*mIt, [callback](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
+            callback({entity, operation});
         });
         mIt++;
         return mIt != mIds.constEnd();
@@ -110,23 +108,23 @@ public:
     bool next(const std::function<void(const ResultSet::Result &result)> &callback) Q_DECL_OVERRIDE {
         bool foundValue = false;
         while(!foundValue && mSource->next([this, callback, &foundValue](const ResultSet::Result &result) {
-                SinkTrace() << "Filter: " << result.uid << result.operation;
+                SinkTrace() << "Filter: " << result.entity.identifier() << result.operation;
 
                 //Always accept removals. They can't match the filter since the data is gone.
                 if (result.operation == Sink::Operation_Removal) {
-                    SinkTrace() << "Removal: " << result.uid << result.operation;
+                    SinkTrace() << "Removal: " << result.entity.identifier() << result.operation;
                     callback(result);
                     foundValue = true;
-                } else if (matchesFilter(result.uid, result.buffer)) {
-                    SinkTrace() << "Accepted: " << result.uid << result.operation;
+                } else if (matchesFilter(result.entity)) {
+                    SinkTrace() << "Accepted: " << result.entity.identifier() << result.operation;
                     callback(result);
                     foundValue = true;
                     //TODO if something did not match the filter so far but does now, turn into an add operation.
                 } else {
-                    SinkTrace() << "Rejected: " << result.uid << result.operation;
+                    SinkTrace() << "Rejected: " << result.entity.identifier() << result.operation;
                     //TODO emit a removal if we had the uid in the result set and this is a modification.
                     //We don't know if this results in a removal from the dataset, so we emit a removal notification anyways
-                    callback({result.uid, result.buffer, Sink::Operation_Removal, result.aggregateValues});
+                    callback({result.entity, Sink::Operation_Removal, result.aggregateValues});
                 }
                 return false;
             }))
@@ -134,9 +132,9 @@ public:
         return foundValue;
     }
 
-    bool matchesFilter(const QByteArray &uid, const Sink::EntityBuffer &entityBuffer) {
+    bool matchesFilter(const ApplicationDomain::ApplicationDomainType &entity) {
         for (const auto &filterProperty : propertyFilter.keys()) {
-            const auto property = getProperty(entityBuffer.entity(), filterProperty);
+            const auto property = entity.getProperty(filterProperty);
             const auto comparator = propertyFilter.value(filterProperty);
             if (!comparator.matches(property)) {
                 SinkTrace() << "Filtering entity due to property mismatch on filter: " << filterProperty << property << ":" << comparator.value;
@@ -224,7 +222,7 @@ public:
     bool next(const std::function<void(const ResultSet::Result &)> &callback) Q_DECL_OVERRIDE {
         bool foundValue = false;
         while(!foundValue && mSource->next([this, callback, &foundValue](const ResultSet::Result &result) {
-                auto reductionValue = getProperty(result.buffer.entity(), mReductionProperty);
+                auto reductionValue = result.entity.getProperty(mReductionProperty);
                 if (!mReducedValues.contains(getByteArray(reductionValue))) {
                     //Only reduce every value once.
                     mReducedValues.insert(getByteArray(reductionValue));
@@ -234,18 +232,18 @@ public:
 
                     QVariantList list;
                     for (const auto r : results) {
-                        readEntity(r, [&, this](const QByteArray &uid, const Sink::EntityBuffer &entityBuffer) {
+                        readEntity(r, [&, this](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
                             for (auto &aggregator : mAggregators) {
                                 if (!aggregator.property.isEmpty()) {
-                                    aggregator.process(getProperty(entityBuffer.entity(), aggregator.property));
+                                    aggregator.process(entity.getProperty(aggregator.property));
                                 } else {
                                     aggregator.process();
                                 }
                             }
-                            auto selectionValue = getProperty(entityBuffer.entity(), mSelectionProperty);
+                            auto selectionValue = entity.getProperty(mSelectionProperty);
                             if (!selectionResultValue.isValid() || compare(selectionValue, selectionResultValue, mSelectionComparator)) {
                                 selectionResultValue = selectionValue;
-                                selectionResult = uid;
+                                selectionResult = entity.identifier();
                             }
                         });
                     }
@@ -255,8 +253,8 @@ public:
                         aggregateValues.insert(aggregator.resultProperty, aggregator.result());
                     }
 
-                    readEntity(selectionResult, [&, this](const QByteArray &uid, const Sink::EntityBuffer &entityBuffer) {
-                        callback({uid, entityBuffer, Sink::Operation_Creation, aggregateValues});
+                    readEntity(selectionResult, [&, this](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
+                        callback({entity, Sink::Operation_Creation, aggregateValues});
                         foundValue = true;
                     });
                 }
@@ -285,11 +283,11 @@ public:
     bool next(const std::function<void(const ResultSet::Result &result)> &callback) Q_DECL_OVERRIDE {
         bool foundValue = false;
         while(!foundValue && mSource->next([this, callback, &foundValue](const ResultSet::Result &result) {
-                auto bloomValue = getProperty(result.buffer.entity(), mBloomProperty);
+                auto bloomValue = result.entity.getProperty(mBloomProperty);
                 auto results = indexLookup(mBloomProperty, bloomValue);
                 for (const auto r : results) {
-                    readEntity(r, [&, this](const QByteArray &uid, const Sink::EntityBuffer &entityBuffer) {
-                        callback({uid, entityBuffer, Sink::Operation_Creation});
+                    readEntity(r, [&, this](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
+                        callback({entity, Sink::Operation_Creation});
                         foundValue = true;
                     });
                 }
@@ -300,23 +298,15 @@ public:
     }
 };
 
-DataStoreQuery::DataStoreQuery(const Sink::Query &query, const QByteArray &type, EntityStore::Ptr store, std::function<QVariant(const Sink::Entity &entity, const QByteArray &property)> getProperty)
-    : mQuery(query), mType(type), mGetProperty(getProperty), mStore(store)
+DataStoreQuery::DataStoreQuery(const Sink::Query &query, const QByteArray &type, EntityStore::Ptr store)
+    : mQuery(query), mType(type), mStore(store)
 {
     setupQuery();
 }
 
 void DataStoreQuery::readEntity(const QByteArray &key, const BufferCallback &resultCallback)
 {
-    mStore->readLatest(mType, key, [=](const QByteArray &key, const Sink::EntityBuffer &buffer) {
-            resultCallback(DataStore::uidFromKey(key), buffer);
-            return false;
-        });
-}
-
-QVariant DataStoreQuery::getProperty(const Sink::Entity &entity, const QByteArray &property)
-{
-    return mGetProperty(entity, property);
+    mStore->readLatest(mType, key, resultCallback);
 }
 
 QVector<QByteArray> DataStoreQuery::indexLookup(const QByteArray &property, const QVariant &value)
@@ -404,28 +394,28 @@ QVector<QByteArray> DataStoreQuery::indexLookup(const QByteArray &property, cons
 /*     } */
 /* } */
 
-template <typename ... Args>
-QSharedPointer<DataStoreQuery> prepareQuery(const QByteArray &type, Args && ... args)
-{
-    if (type == ApplicationDomain::getTypeName<ApplicationDomain::Folder>()) {
-        return ApplicationDomain::TypeImplementation<ApplicationDomain::Folder>::prepareQuery(std::forward<Args>(args)...);
-    } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Mail>()) {
-        return ApplicationDomain::TypeImplementation<ApplicationDomain::Mail>::prepareQuery(std::forward<Args>(args)...);
-    } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Event>()) {
-        return ApplicationDomain::TypeImplementation<ApplicationDomain::Event>::prepareQuery(std::forward<Args>(args)...);
-    }
-    Q_ASSERT(false);
-    return QSharedPointer<DataStoreQuery>();
-}
+/* template <typename ... Args> */
+/* QSharedPointer<DataStoreQuery> prepareQuery(const QByteArray &type, Args && ... args) */
+/* { */
+/*     if (type == ApplicationDomain::getTypeName<ApplicationDomain::Folder>()) { */
+/*         return ApplicationDomain::TypeImplementation<ApplicationDomain::Folder>::prepareQuery(std::forward<Args>(args)...); */
+/*     } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Mail>()) { */
+/*         return ApplicationDomain::TypeImplementation<ApplicationDomain::Mail>::prepareQuery(std::forward<Args>(args)...); */
+/*     } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Event>()) { */
+/*         return ApplicationDomain::TypeImplementation<ApplicationDomain::Event>::prepareQuery(std::forward<Args>(args)...); */
+/*     } */
+/*     Q_ASSERT(false); */
+/*     return QSharedPointer<DataStoreQuery>(); */
+/* } */
 
 QByteArrayList DataStoreQuery::executeSubquery(const Query &subquery)
 {
     Q_ASSERT(!subquery.type.isEmpty());
-    auto sub = prepareQuery(subquery.type, subquery, mStore);
-    auto result = sub->execute();
+    auto sub = DataStoreQuery(subquery, subquery.type, mStore);
+    auto result = sub.execute();
     QByteArrayList ids;
     while (result.next([&ids](const ResultSet::Result &result) {
-            ids << result.uid;
+            ids << result.entity.identifier();
         }))
     {}
     return ids;
@@ -518,7 +508,7 @@ ResultSet DataStoreQuery::update(qint64 baseRevision)
     mSource->add(incrementalResultSet);
     ResultSet::ValueGenerator generator = [this](const ResultSet::Callback &callback) -> bool {
         if (mCollector->next([this, callback](const ResultSet::Result &result) {
-                SinkTrace() << "Got incremental result: " << result.uid << result.operation;
+                SinkTrace() << "Got incremental result: " << result.entity.identifier() << result.operation;
                 callback(result);
             }))
         {
@@ -537,8 +527,8 @@ ResultSet DataStoreQuery::execute()
     ResultSet::ValueGenerator generator = [this](const ResultSet::Callback &callback) -> bool {
         if (mCollector->next([this, callback](const ResultSet::Result &result) {
                 if (result.operation != Sink::Operation_Removal) {
-                    SinkTrace() << "Got initial result: " << result.uid << result.operation;
-                    callback(ResultSet::Result{result.uid, result.buffer, Sink::Operation_Creation, result.aggregateValues});
+                    SinkTrace() << "Got initial result: " << result.entity.identifier() << result.operation;
+                    callback(ResultSet::Result{result.entity, Sink::Operation_Creation, result.aggregateValues});
                 }
             }))
         {
diff --git a/common/datastorequery.h b/common/datastorequery.h
index 77c8ed5..92235fd 100644
--- a/common/datastorequery.h
+++ b/common/datastorequery.h
@@ -35,21 +35,20 @@ class DataStoreQuery {
 public:
     typedef QSharedPointer<DataStoreQuery> Ptr;
 
-    DataStoreQuery(const Sink::Query &query, const QByteArray &type, Sink::Storage::EntityStore::Ptr store, std::function<QVariant(const Sink::Entity &entity, const QByteArray &property)> getProperty);
+    DataStoreQuery(const Sink::Query &query, const QByteArray &type, Sink::Storage::EntityStore::Ptr store);
     ResultSet execute();
     ResultSet update(qint64 baseRevision);
 
 private:
 
-    typedef std::function<bool(const QByteArray &uid, const Sink::EntityBuffer &entityBuffer)> FilterFunction;
-    typedef std::function<void(const QByteArray &uid, const Sink::EntityBuffer &entityBuffer)> BufferCallback;
+    typedef std::function<bool(const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation)> FilterFunction;
+    typedef std::function<void(const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation)> BufferCallback;
 
-    virtual QVariant getProperty(const Sink::Entity &entity, const QByteArray &property);
     QVector<QByteArray> indexLookup(const QByteArray &property, const QVariant &value);
 
     virtual void readEntity(const QByteArray &key, const BufferCallback &resultCallback);
 
-    ResultSet createFilteredSet(ResultSet &resultSet, const std::function<bool(const QByteArray &, const Sink::EntityBuffer &buffer)> &);
+    ResultSet createFilteredSet(ResultSet &resultSet, const FilterFunction &);
     QVector<QByteArray> loadIncrementalResultSet(qint64 baseRevision);
 
     void setupQuery();
@@ -57,7 +56,6 @@ private:
 
     Sink::Query mQuery;
     const QByteArray mType;
-    std::function<QVariant(const Sink::Entity &entity, const QByteArray &property)> mGetProperty;
     bool mInitialQuery;
     QSharedPointer<FilterBase> mCollector;
     QSharedPointer<Source> mSource;
@@ -85,18 +83,12 @@ public:
 
     virtual ~FilterBase(){}
 
-    void readEntity(const QByteArray &key, const std::function<void(const QByteArray &, const Sink::EntityBuffer &buffer)> &callback)
+    void readEntity(const QByteArray &key, const std::function<void(const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation)> &callback)
     {
         Q_ASSERT(mDatastore);
         mDatastore->readEntity(key, callback);
     }
 
-    QVariant getProperty(const Sink::Entity &entity, const QByteArray &property)
-    {
-        Q_ASSERT(mDatastore);
-        return mDatastore->getProperty(entity, property);
-    }
-
     QVector<QByteArray> indexLookup(const QByteArray &property, const QVariant &value)
     {
         Q_ASSERT(mDatastore);
diff --git a/common/domain/event.cpp b/common/domain/event.cpp
index 6717187..d50652d 100644
--- a/common/domain/event.cpp
+++ b/common/domain/event.cpp
@@ -87,13 +87,3 @@ QSharedPointer<WritePropertyMapper<TypeImplementation<Event>::BufferBuilder> > T
     propertyMapper->addMapping<Event::Attachment>(&BufferBuilder::add_attachment);
     return propertyMapper;
 }
-
-DataStoreQuery::Ptr TypeImplementation<Event>::prepareQuery(const Sink::Query &query, Sink::Storage::EntityStore::Ptr store)
-{
-    auto mapper = initializeReadPropertyMapper();
-    return DataStoreQuery::Ptr::create(query, ApplicationDomain::getTypeName<Event>(), store, [mapper](const Sink::Entity &entity, const QByteArray &property) {
-
-        const auto localBuffer = Sink::EntityBuffer::readBuffer<Buffer>(entity.local());
-        return mapper->getProperty(property, localBuffer);
-    });
-}
diff --git a/common/domain/event.h b/common/domain/event.h
index ce9691d..18e0f20 100644
--- a/common/domain/event.h
+++ b/common/domain/event.h
@@ -56,8 +56,6 @@ public:
     typedef Sink::ApplicationDomain::Buffer::EventBuilder BufferBuilder;
     static void configureIndex(TypeIndex &index);
     static QSet<QByteArray> indexedProperties();
-    static QSharedPointer<DataStoreQuery> prepareQuery(const Sink::Query &query, Sink::Storage::EntityStore::Ptr store);
-
     static void index(const QByteArray &identifier, const BufferAdaptor &bufferAdaptor, Sink::Storage::DataStore::Transaction &transaction);
     static void removeIndex(const QByteArray &identifier, const BufferAdaptor &bufferAdaptor, Sink::Storage::DataStore::Transaction &transaction);
     static QSharedPointer<ReadPropertyMapper<Buffer> > initializeReadPropertyMapper();
diff --git a/common/domain/folder.cpp b/common/domain/folder.cpp
index 34e59f6..94727a3 100644
--- a/common/domain/folder.cpp
+++ b/common/domain/folder.cpp
@@ -91,12 +91,3 @@ QSharedPointer<WritePropertyMapper<TypeImplementation<Folder>::BufferBuilder> >
     propertyMapper->addMapping<Folder::SpecialPurpose>(&BufferBuilder::add_specialpurpose);
     return propertyMapper;
 }
-
-DataStoreQuery::Ptr TypeImplementation<Folder>::prepareQuery(const Sink::Query &query, Sink::Storage::EntityStore::Ptr store)
-{
-    auto mapper = initializeReadPropertyMapper();
-    return DataStoreQuery::Ptr::create(query, ApplicationDomain::getTypeName<Folder>(), store, [mapper](const Sink::Entity &entity, const QByteArray &property) {
-        const auto localBuffer = Sink::EntityBuffer::readBuffer<Buffer>(entity.local());
-        return mapper->getProperty(property, localBuffer);
-    });
-}
diff --git a/common/domain/folder.h b/common/domain/folder.h
index 0a52b01..ea0d79a 100644
--- a/common/domain/folder.h
+++ b/common/domain/folder.h
@@ -49,7 +49,6 @@ public:
     typedef Sink::ApplicationDomain::Buffer::Folder Buffer;
     typedef Sink::ApplicationDomain::Buffer::FolderBuilder BufferBuilder;
     static void configureIndex(TypeIndex &index);
-    static QSharedPointer<DataStoreQuery> prepareQuery(const Sink::Query &query, Sink::Storage::EntityStore::Ptr store);
     static QSet<QByteArray> indexedProperties();
     static void index(const QByteArray &identifier, const BufferAdaptor &bufferAdaptor, Sink::Storage::DataStore::Transaction &transaction);
     static void removeIndex(const QByteArray &identifier, const BufferAdaptor &bufferAdaptor, Sink::Storage::DataStore::Transaction &transaction);
diff --git a/common/domain/mail.cpp b/common/domain/mail.cpp
index 9e3a824..b0a3aae 100644
--- a/common/domain/mail.cpp
+++ b/common/domain/mail.cpp
@@ -225,26 +225,3 @@ QSharedPointer<WritePropertyMapper<TypeImplementation<Mail>::BufferBuilder> > Ty
 }
 
 
-DataStoreQuery::Ptr TypeImplementation<Mail>::prepareQuery(const Sink::Query &query, Sink::Storage::EntityStore::Ptr store)
-{
-    auto mapper = initializeReadPropertyMapper();
-    return DataStoreQuery::Ptr::create(query, ApplicationDomain::getTypeName<Mail>(), store, [mapper, store](const Sink::Entity &entity, const QByteArray &property) -> QVariant {
-        if (property == Mail::ThreadId::name) {
-            const auto localBuffer = Sink::EntityBuffer::readBuffer<Buffer>(entity.local());
-            Q_ASSERT(localBuffer);
-            auto messageId = mapper->getProperty(Mail::MessageId::name, localBuffer);
-            //FIXME
-            //This is an index property that we have too lookup
-            /* auto thread = getIndex().secondaryLookup<Mail::MessageId, Mail::ThreadId>(messageId); */
-            /* auto thread = store->secondaryLookup<Mail::MessageId, Mail::ThreadId>(messageId); */
-            /* Q_ASSERT(!thread.isEmpty()); */
-            /* return thread.first(); */
-            return QVariant();
-        } else {
-            const auto localBuffer = Sink::EntityBuffer::readBuffer<Buffer>(entity.local());
-            Q_ASSERT(localBuffer);
-            return mapper->getProperty(property, localBuffer);
-        }
-    });
-}
-
diff --git a/common/domain/mail.h b/common/domain/mail.h
index 6c1f670..81a0d1c 100644
--- a/common/domain/mail.h
+++ b/common/domain/mail.h
@@ -49,7 +49,6 @@ public:
     typedef Sink::ApplicationDomain::Buffer::Mail Buffer;
     typedef Sink::ApplicationDomain::Buffer::MailBuilder BufferBuilder;
     static void configureIndex(TypeIndex &index);
-    static QSharedPointer<DataStoreQuery> prepareQuery(const Sink::Query &query, Sink::Storage::EntityStore::Ptr storage);
     static QSet<QByteArray> indexedProperties();
     static void index(const QByteArray &identifier, const BufferAdaptor &bufferAdaptor, Sink::Storage::DataStore::Transaction &transaction);
     static void removeIndex(const QByteArray &identifier, const BufferAdaptor &bufferAdaptor, Sink::Storage::DataStore::Transaction &transaction);
diff --git a/common/queryrunner.cpp b/common/queryrunner.cpp
index 4422229..67e83ea 100644
--- a/common/queryrunner.cpp
+++ b/common/queryrunner.cpp
@@ -176,10 +176,7 @@ QueryWorker<DomainType>::~QueryWorker()
 template <class DomainType>
 void QueryWorker<DomainType>::resultProviderCallback(const Sink::Query &query, Sink::ResultProviderInterface<typename DomainType::Ptr> &resultProvider, const ResultSet::Result &result)
 {
-    auto adaptor = mResourceContext.adaptorFactory<DomainType>().createAdaptor(result.buffer.entity());
-    Q_ASSERT(adaptor);
-    auto domainObject = DomainType{mResourceContext.instanceId(), result.uid, result.buffer.revision(), adaptor};
-    auto valueCopy = Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(domainObject, query.requestedProperties).template staticCast<DomainType>();
+    auto valueCopy = Sink::ApplicationDomain::ApplicationDomainType::getInMemoryRepresentation<DomainType>(result.entity, query.requestedProperties).template staticCast<DomainType>();
     for (auto it = result.aggregateValues.constBegin(); it != result.aggregateValues.constEnd(); it++) {
         valueCopy->setProperty(it.key(), it.value());
     }
@@ -208,12 +205,10 @@ QPair<qint64, qint64> QueryWorker<DomainType>::executeIncrementalQuery(const Sin
     QTime time;
     time.start();
 
-    auto entityStore = EntityStore::Ptr::create(mResourceContext);
-
     const qint64 baseRevision = resultProvider.revision() + 1;
-
-    auto preparedQuery = ApplicationDomain::TypeImplementation<DomainType>::prepareQuery(query, entityStore);
-    auto resultSet = preparedQuery->update(baseRevision);
+    auto entityStore = EntityStore::Ptr::create(mResourceContext);
+    auto preparedQuery = DataStoreQuery{query, ApplicationDomain::getTypeName<DomainType>(), entityStore};
+    auto resultSet = preparedQuery.update(baseRevision);
     SinkTrace() << "Filtered set retrieved. " << Log::TraceTime(time.elapsed());
     auto replayedEntities = resultSet.replaySet(0, 0, [this, query, &resultProvider](const ResultSet::Result &result) {
         resultProviderCallback(query, resultProvider, result);
@@ -242,9 +237,8 @@ QPair<qint64, qint64> QueryWorker<DomainType>::executeInitialQuery(
     }
 
     auto entityStore = EntityStore::Ptr::create(mResourceContext);
-
-    auto preparedQuery = ApplicationDomain::TypeImplementation<DomainType>::prepareQuery(query, entityStore);
-    auto resultSet = preparedQuery->execute();
+    auto preparedQuery = DataStoreQuery{query, ApplicationDomain::getTypeName<DomainType>(), entityStore};
+    auto resultSet = preparedQuery.execute();
 
     SinkTrace() << "Filtered set retrieved. " << Log::TraceTime(time.elapsed());
     auto replayedEntities = resultSet.replaySet(offset, batchsize, [this, query, &resultProvider](const ResultSet::Result &result) {
diff --git a/common/resultset.h b/common/resultset.h
index a86a2e2..4f2c278 100644
--- a/common/resultset.h
+++ b/common/resultset.h
@@ -24,6 +24,7 @@
 #include <functional>
 #include "metadata_generated.h"
 #include "entitybuffer.h"
+#include "applicationdomaintype.h"
 
 /*
  * An iterator to a result set.
@@ -34,8 +35,7 @@ class ResultSet
 {
 public:
     struct Result {
-        QByteArray uid;
-        Sink::EntityBuffer buffer;
+        Sink::ApplicationDomain::ApplicationDomainType entity;
         Sink::Operation operation;
         QMap<QByteArray, QVariant> aggregateValues;
     };
diff --git a/common/storage/entitystore.cpp b/common/storage/entitystore.cpp
index 9615eca..fe63f0b 100644
--- a/common/storage/entitystore.cpp
+++ b/common/storage/entitystore.cpp
@@ -184,6 +184,15 @@ void EntityStore::readLatest(const QByteArray &type, const QByteArray &uid, cons
     });
 }
 
+void EntityStore::readLatest(const QByteArray &type, const QByteArray &uid, const std::function<void(const ApplicationDomain::ApplicationDomainType &, Sink::Operation)> callback)
+{
+    readLatest(type, uid, [&](const QByteArray &uid, const EntityBuffer &buffer) {
+        auto adaptor = d->resourceContext.adaptorFactory(type).createAdaptor(buffer.entity());
+        //TODO cache max revision for the duration of the transaction.
+        callback(ApplicationDomain::ApplicationDomainType{d->resourceContext.instanceId(), uid, DataStore::maxRevision(d->getTransaction()), adaptor}, buffer.operation());
+    });
+}
+
 ApplicationDomain::ApplicationDomainType EntityStore::readLatest(const QByteArray &type, const QByteArray &uid)
 {
     ApplicationDomain::ApplicationDomainType dt;
diff --git a/common/storage/entitystore.h b/common/storage/entitystore.h
index de29e87..455e9c3 100644
--- a/common/storage/entitystore.h
+++ b/common/storage/entitystore.h
@@ -26,6 +26,7 @@
 #include "query.h"
 #include "storage.h"
 #include "resourcecontext.h"
+#include "metadata_generated.h"
 
 namespace Sink {
 class EntityBuffer;
@@ -56,6 +57,7 @@ public:
 
     void readLatest(const QByteArray &type, const QByteArray &uid, const std::function<void(const QByteArray &uid, const EntityBuffer &entity)> callback);
     void readLatest(const QByteArray &type, const QByteArray &uid, const std::function<void(const ApplicationDomain::ApplicationDomainType &entity)> callback);
+    void readLatest(const QByteArray &type, const QByteArray &uid, const std::function<void(const ApplicationDomain::ApplicationDomainType &entity, Sink::Operation)> callback);
 
     ApplicationDomain::ApplicationDomainType readLatest(const QByteArray &type, const QByteArray &uid);