Finish converting DataStoreQuery to new Key API

1 files changed, 36 insertions, 23 deletions

diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index fd910f8..8bfc49b 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -41,17 +41,23 @@ class Source : public FilterBase {
     public:
     typedef QSharedPointer<Source> Ptr;
 
-    QVector<QByteArray> mIds;
-    QVector<QByteArray>::ConstIterator mIt;
-    QVector<QByteArray> mIncrementalIds;
-    QVector<QByteArray>::ConstIterator mIncrementalIt;
+    QVector<Identifier> mIds;
+    QVector<Identifier>::ConstIterator mIt;
+    QVector<Identifier> mIncrementalIds;
+    QVector<Identifier>::ConstIterator mIncrementalIt;
 
     Source (const QVector<QByteArray> &ids, DataStoreQuery *store)
         : FilterBase(store),
-        mIds(ids),
-        mIt(mIds.constBegin())
+        mIds()
     {
-
+        // Use reserve + append instead of QVector constructor with size here
+        // to avoid default construction, which would generate a new random
+        // Uuid
+        mIds.reserve(ids.size());
+        for (const auto &id : ids) {
+            mIds.append(Identifier::fromDisplayByteArray(id));
+        }
+        mIt = mIds.constBegin();
     }
 
     virtual ~Source(){}
@@ -63,9 +69,15 @@ class Source : public FilterBase {
         }
     };
 
-    void add(const QVector<QByteArray> &ids)
+    void add(const QVector<Key> &keys)
     {
-        mIncrementalIds = ids;
+        // Use clear + reserve + append instead of resize here to avoid default
+        // construction
+        mIncrementalIds.clear();
+        mIncrementalIds.reserve(keys.size());
+        for (const auto &key : keys) {
+            mIncrementalIds.append(key.identifier());
+        }
         mIncrementalIt = mIncrementalIds.constBegin();
     }
 
@@ -284,7 +296,7 @@ public:
                 if (!matchesFilter(entity)) {
                     return;
                 }
-                reducedAndFilteredResults << r;
+                reducedAndFilteredResults << r.toDisplayByteArray();
                 Q_ASSERT(operation != Sink::Operation_Removal);
                 for (auto &aggregator : mAggregators) {
                     if (!aggregator.property.isEmpty()) {
@@ -318,7 +330,8 @@ public:
                     if (v.isNull() && result.operation == Sink::Operation_Removal) {
                         //For removals we have to read the last revision to get a value, and thus be able to find the correct thread.
                         QVariant reductionValue;
-                        readPrevious(result.entity.identifier(), [&] (const ApplicationDomain::ApplicationDomainType &prev) {
+                        const auto id = Identifier::fromDisplayByteArray(result.entity.identifier());
+                        readPrevious(id, [&] (const ApplicationDomain::ApplicationDomainType &prev) {
                             Q_ASSERT(result.entity.identifier() == prev.identifier());
                             reductionValue = prev.getProperty(mReductionProperty);
                         });
@@ -345,7 +358,7 @@ public:
                         return;
                     }
                     mSelectedValues.insert(reductionValueBa, reductionResult.selection);
-                    readEntity(reductionResult.selection, [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
+                    readEntity(Identifier::fromDisplayByteArray(reductionResult.selection), [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation operation) {
                         callback({entity, operation, reductionResult.aggregateValues, reductionResult.aggregateIds});
                         foundValue = true;
                     });
@@ -368,13 +381,13 @@ public:
                         if (oldSelectionResult == selectionResult.selection) {
                             mSelectedValues.insert(reductionValueBa, selectionResult.selection);
                             Q_ASSERT(!selectionResult.selection.isEmpty());
-                            readEntity(selectionResult.selection, [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation) {
+                            readEntity(Identifier::fromDisplayByteArray(selectionResult.selection), [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation) {
                                 callback({entity, Sink::Operation_Modification, selectionResult.aggregateValues, selectionResult.aggregateIds});
                             });
                         } else {
                             //remove old result
                             Q_ASSERT(!oldSelectionResult.isEmpty());
-                            readEntity(oldSelectionResult, [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation) {
+                            readEntity(Identifier::fromDisplayByteArray(oldSelectionResult), [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation) {
                                 callback({entity, Sink::Operation_Removal});
                             });
 
@@ -383,7 +396,7 @@ public:
                                 //add new result
                                 mSelectedValues.insert(reductionValueBa, selectionResult.selection);
                                 Q_ASSERT(!selectionResult.selection.isEmpty());
-                                readEntity(selectionResult.selection, [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation) {
+                                readEntity(Identifier::fromDisplayByteArray(selectionResult.selection), [&](const Sink::ApplicationDomain::ApplicationDomainType &entity, Sink::Operation) {
                                     callback({entity, Sink::Operation_Creation, selectionResult.aggregateValues, selectionResult.aggregateIds});
                                 });
                             }
@@ -477,17 +490,17 @@ DataStoreQuery::State::Ptr DataStoreQuery::getState()
     return state;
 }
 
-void DataStoreQuery::readEntity(const QByteArray &key, const BufferCallback &resultCallback)
+void DataStoreQuery::readEntity(const Identifier &id, const BufferCallback &resultCallback)
 {
-    mStore.readLatest(mType, key, resultCallback);
+    mStore.readLatest(mType, id, resultCallback);
 }
 
-void DataStoreQuery::readPrevious(const QByteArray &key, const std::function<void (const ApplicationDomain::ApplicationDomainType &)> &callback)
+void DataStoreQuery::readPrevious(const Identifier &id, const std::function<void (const ApplicationDomain::ApplicationDomainType &)> &callback)
 {
-    mStore.readPrevious(mType, key, mStore.maxRevision(), callback);
+    mStore.readPrevious(mType, id, mStore.maxRevision(), callback);
 }
 
-QVector<QByteArray> DataStoreQuery::indexLookup(const QByteArray &property, const QVariant &value)
+QVector<Identifier> DataStoreQuery::indexLookup(const QByteArray &property, const QVariant &value)
 {
     return mStore.indexLookup(mType, property, value);
 }
@@ -654,10 +667,10 @@ void DataStoreQuery::setupQuery(const Sink::QueryBase &query_)
     mCollector = Collector::Ptr::create(baseSet, this);
 }
 
-QVector<QByteArray> DataStoreQuery::loadIncrementalResultSet(qint64 baseRevision)
+QVector<Key> DataStoreQuery::loadIncrementalResultSet(qint64 baseRevision)
 {
-    QVector<QByteArray> changedKeys;
-    mStore.readRevisions(baseRevision, mType, [&](const QByteArray &key) {
+    QVector<Key> changedKeys;
+    mStore.readRevisions(baseRevision, mType, [&](const Key &key) {
         changedKeys << key;
     });
     return changedKeys;