Refactor how the storage is used.

This is the initial refactoring to improve how we deal with the storage.

It does a couple of things:
* Rename Sink::Storage to Sink::Storage::DataStore to free up the
  Sink::Storage namespace
* Introduce a Sink::ResourceContext to have a single object that can be
  passed around containing everything that is necessary to operate on a
  resource. This is a lot better than the multiple separate parameters
  that we used to pass around all over the place, while still allowing
  for dependency injection for tests.
* Tie storage access together using the new EntityStore that directly
  works with ApplicationDomainTypes. This gives us a central place where
  main storage, indexes and buffer adaptors are tied together, which
  will also give us a place to implement external indexes, such as a
  fulltextindex using xapian.
* Use ApplicationDomainTypes as the default way to pass around entities.
  Instead of using various ways to pass around entities (buffers,
  buffer adaptors, ApplicationDomainTypes), only use a single way.
  The old approach was confusing, and was only done as:
  * optimization; really shouldn't be necessary and otherwise I'm sure
  we can find better ways to optimize ApplicationDomainType itself.
  * a way to account for entities that have multiple buffers, a concept
  that I no longer deem relevant.

While this commit does the bulk of the work to get there, the following
commits will refactor more stuff to get things back to normal.

1 files changed, 102 insertions, 107 deletions

diff --git a/common/entityreader.cpp b/common/entityreader.cpp
index cca1511..c49d1f7 100644
--- a/common/entityreader.cpp
+++ b/common/entityreader.cpp
@@ -28,75 +28,82 @@ SINK_DEBUG_AREA("entityreader")
 
 using namespace Sink;
 
-QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> EntityReaderUtils::getLatest(const Sink::Storage::NamedDatabase &db, const QByteArray &uid, DomainTypeAdaptorFactoryInterface &adaptorFactory, qint64 &retrievedRevision)
-{
-    QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> current;
-    db.findLatest(uid,
-        [&current, &adaptorFactory, &retrievedRevision](const QByteArray &key, const QByteArray &data) -> bool {
-            Sink::EntityBuffer buffer(const_cast<const char *>(data.data()), data.size());
-            if (!buffer.isValid()) {
-                SinkWarning() << "Read invalid buffer from disk";
-            } else {
-                SinkTrace() << "Found value " << key;
-                current = adaptorFactory.createAdaptor(buffer.entity());
-                retrievedRevision = Sink::Storage::revisionFromKey(key);
-            }
-            return false;
-        },
-        [](const Sink::Storage::Error &error) { SinkWarning() << "Failed to read current value from storage: " << error.message; });
-    return current;
-}
-
-QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> EntityReaderUtils::get(const Sink::Storage::NamedDatabase &db, const QByteArray &key, DomainTypeAdaptorFactoryInterface &adaptorFactory, qint64 &retrievedRevision)
-{
-    QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> current;
-    db.scan(key,
-        [&current, &adaptorFactory, &retrievedRevision](const QByteArray &key, const QByteArray &data) -> bool {
-            Sink::EntityBuffer buffer(const_cast<const char *>(data.data()), data.size());
-            if (!buffer.isValid()) {
-                SinkWarning() << "Read invalid buffer from disk";
-            } else {
-                current = adaptorFactory.createAdaptor(buffer.entity());
-                retrievedRevision = Sink::Storage::revisionFromKey(key);
-            }
-            return false;
-        },
-        [](const Sink::Storage::Error &error) { SinkWarning() << "Failed to read current value from storage: " << error.message; });
-    return current;
-}
-
-QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> EntityReaderUtils::getPrevious(const Sink::Storage::NamedDatabase &db, const QByteArray &uid, qint64 revision, DomainTypeAdaptorFactoryInterface &adaptorFactory, qint64 &retrievedRevision)
-{
-    QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> current;
-    qint64 latestRevision = 0;
-    db.scan(uid,
-        [&current, &latestRevision, revision](const QByteArray &key, const QByteArray &) -> bool {
-            auto foundRevision = Sink::Storage::revisionFromKey(key);
-            if (foundRevision < revision && foundRevision > latestRevision) {
-                latestRevision = foundRevision;
-            }
-            return true;
-        },
-        [](const Sink::Storage::Error &error) { SinkWarning() << "Failed to read current value from storage: " << error.message; }, true);
-    return get(db, Sink::Storage::assembleKey(uid, latestRevision), adaptorFactory, retrievedRevision);
-}
+/* QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> EntityReaderUtils::getLatest(const Sink::Storage::DataStore::NamedDatabase &db, const QByteArray &uid, DomainTypeAdaptorFactoryInterface &adaptorFactory, qint64 &retrievedRevision) */
+/* { */
+/*     QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> current; */
+/*     db.findLatest(uid, */
+/*         [&current, &adaptorFactory, &retrievedRevision](const QByteArray &key, const QByteArray &data) -> bool { */
+/*             Sink::EntityBuffer buffer(const_cast<const char *>(data.data()), data.size()); */
+/*             if (!buffer.isValid()) { */
+/*                 SinkWarning() << "Read invalid buffer from disk"; */
+/*             } else { */
+/*                 SinkTrace() << "Found value " << key; */
+/*                 current = adaptorFactory.createAdaptor(buffer.entity()); */
+/*                 retrievedRevision = Sink::Storage::DataStore::revisionFromKey(key); */
+/*             } */
+/*             return false; */
+/*         }, */
+/*         [](const Sink::Storage::DataStore::Error &error) { SinkWarning() << "Failed to read current value from storage: " << error.message; }); */
+/*     return current; */
+/* } */
+
+/* QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> EntityReaderUtils::get(const Sink::Storage::DataStore::NamedDatabase &db, const QByteArray &key, DomainTypeAdaptorFactoryInterface &adaptorFactory, qint64 &retrievedRevision) */
+/* { */
+/*     QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> current; */
+/*     db.scan(key, */
+/*         [&current, &adaptorFactory, &retrievedRevision](const QByteArray &key, const QByteArray &data) -> bool { */
+/*             Sink::EntityBuffer buffer(const_cast<const char *>(data.data()), data.size()); */
+/*             if (!buffer.isValid()) { */
+/*                 SinkWarning() << "Read invalid buffer from disk"; */
+/*             } else { */
+/*                 current = adaptorFactory.createAdaptor(buffer.entity()); */
+/*                 retrievedRevision = Sink::Storage::DataStore::revisionFromKey(key); */
+/*             } */
+/*             return false; */
+/*         }, */
+/*         [](const Sink::Storage::DataStore::Error &error) { SinkWarning() << "Failed to read current value from storage: " << error.message; }); */
+/*     return current; */
+/* } */
+
+/* QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> EntityReaderUtils::getPrevious(const Sink::Storage::DataStore::NamedDatabase &db, const QByteArray &uid, qint64 revision, DomainTypeAdaptorFactoryInterface &adaptorFactory, qint64 &retrievedRevision) */
+/* { */
+/*     QSharedPointer<Sink::ApplicationDomain::BufferAdaptor> current; */
+/*     qint64 latestRevision = 0; */
+/*     db.scan(uid, */
+/*         [&current, &latestRevision, revision](const QByteArray &key, const QByteArray &) -> bool { */
+/*             auto foundRevision = Sink::Storage::DataStore::revisionFromKey(key); */
+/*             if (foundRevision < revision && foundRevision > latestRevision) { */
+/*                 latestRevision = foundRevision; */
+/*             } */
+/*             return true; */
+/*         }, */
+/*         [](const Sink::Storage::DataStore::Error &error) { SinkWarning() << "Failed to read current value from storage: " << error.message; }, true); */
+/*     return get(db, Sink::Storage::DataStore::assembleKey(uid, latestRevision), adaptorFactory, retrievedRevision); */
+/* } */
+
+/* template <class DomainType> */
+/* EntityReader<DomainType>::EntityReader(const QByteArray &resourceType, const QByteArray &resourceInstanceIdentifier, Sink::Storage::DataStore::Transaction &transaction) */
+/*     : mResourceInstanceIdentifier(resourceInstanceIdentifier), */
+/*     mTransaction(transaction), */
+/*     mDomainTypeAdaptorFactoryPtr(Sink::AdaptorFactoryRegistry::instance().getFactory<DomainType>(resourceType)), */
+/*     mDomainTypeAdaptorFactory(*mDomainTypeAdaptorFactoryPtr) */
+/* { */
+/*     Q_ASSERT(!resourceType.isEmpty()); */
+/*     Q_ASSERT(mDomainTypeAdaptorFactoryPtr); */
+/* } */
+
+/* template <class DomainType> */
+/* EntityReader<DomainType>::EntityReader(DomainTypeAdaptorFactoryInterface &domainTypeAdaptorFactory, const QByteArray &resourceInstanceIdentifier, Sink::Storage::DataStore::Transaction &transaction) */
+/*     : mResourceInstanceIdentifier(resourceInstanceIdentifier), */
+/*     mTransaction(transaction), */
+/*     mDomainTypeAdaptorFactory(domainTypeAdaptorFactory) */
+/* { */
+
+/* } */
 
 template <class DomainType>
-EntityReader<DomainType>::EntityReader(const QByteArray &resourceType, const QByteArray &resourceInstanceIdentifier, Sink::Storage::Transaction &transaction)
-    : mResourceInstanceIdentifier(resourceInstanceIdentifier),
-    mTransaction(transaction),
-    mDomainTypeAdaptorFactoryPtr(Sink::AdaptorFactoryRegistry::instance().getFactory<DomainType>(resourceType)),
-    mDomainTypeAdaptorFactory(*mDomainTypeAdaptorFactoryPtr)
-{
-    Q_ASSERT(!resourceType.isEmpty());
-    Q_ASSERT(mDomainTypeAdaptorFactoryPtr);
-}
-
-template <class DomainType>
-EntityReader<DomainType>::EntityReader(DomainTypeAdaptorFactoryInterface &domainTypeAdaptorFactory, const QByteArray &resourceInstanceIdentifier, Sink::Storage::Transaction &transaction)
-    : mResourceInstanceIdentifier(resourceInstanceIdentifier),
-    mTransaction(transaction),
-    mDomainTypeAdaptorFactory(domainTypeAdaptorFactory)
+EntityReader<DomainType>::EntityReader(Storage::EntityStore &entityStore)
+    : mEntityStore(entityStore)
 {
 
 }
@@ -105,40 +112,28 @@ template <class DomainType>
 DomainType EntityReader<DomainType>::read(const QByteArray &identifier) const
 {
     auto typeName = ApplicationDomain::getTypeName<DomainType>();
-    auto mainDatabase = Storage::mainDatabase(mTransaction, typeName);
-    qint64 retrievedRevision = 0;
-    auto bufferAdaptor = EntityReaderUtils::getLatest(mainDatabase, identifier, mDomainTypeAdaptorFactory, retrievedRevision);
-    if (!bufferAdaptor) {
-        return DomainType();
-    }
-    return DomainType(mResourceInstanceIdentifier, identifier, retrievedRevision, bufferAdaptor);
+    return mEntityStore.readLatest<DomainType>(identifier);
 }
 
 template <class DomainType>
 DomainType EntityReader<DomainType>::readFromKey(const QByteArray &key) const
 {
-    auto typeName = ApplicationDomain::getTypeName<DomainType>();
-    auto mainDatabase = Storage::mainDatabase(mTransaction, typeName);
-    qint64 retrievedRevision = 0;
-    auto bufferAdaptor = EntityReaderUtils::get(mainDatabase, key, mDomainTypeAdaptorFactory, retrievedRevision);
-    const auto identifier = Storage::uidFromKey(key);
-    if (!bufferAdaptor) {
-        return DomainType();
-    }
-    return DomainType(mResourceInstanceIdentifier, identifier, retrievedRevision, bufferAdaptor);
+    /* auto typeName = ApplicationDomain::getTypeName<DomainType>(); */
+    /* auto mainDatabase = Storage::DataStore::mainDatabase(mTransaction, typeName); */
+    /* qint64 retrievedRevision = 0; */
+    /* auto bufferAdaptor = EntityReaderUtils::get(mainDatabase, key, mDomainTypeAdaptorFactory, retrievedRevision); */
+    /* const auto identifier = Storage::DataStore::uidFromKey(key); */
+    /* if (!bufferAdaptor) { */
+    /*     return DomainType(); */
+    /* } */
+    /* return DomainType(mResourceInstanceIdentifier, identifier, retrievedRevision, bufferAdaptor); */
+    return mEntityStore.readEntity<DomainType>(key);
 }
 
 template <class DomainType>
 DomainType EntityReader<DomainType>::readPrevious(const QByteArray &uid, qint64 revision) const
 {
-    auto typeName = ApplicationDomain::getTypeName<DomainType>();
-    auto mainDatabase = Storage::mainDatabase(mTransaction, typeName);
-    qint64 retrievedRevision = 0;
-    auto bufferAdaptor = EntityReaderUtils::getPrevious(mainDatabase, uid, revision, mDomainTypeAdaptorFactory, retrievedRevision);
-    if (!bufferAdaptor) {
-        return DomainType();
-    }
-    return DomainType(mResourceInstanceIdentifier, uid, retrievedRevision, bufferAdaptor);
+    return mEntityStore.readPrevious<DomainType>(uid, revision);
 }
 
 template <class DomainType>
@@ -157,14 +152,14 @@ QPair<qint64, qint64> EntityReader<DomainType>::executeInitialQuery(const Sink::
     QTime time;
     time.start();
 
-    auto preparedQuery = ApplicationDomain::TypeImplementation<DomainType>::prepareQuery(query, mTransaction);
+    auto preparedQuery = ApplicationDomain::TypeImplementation<DomainType>::prepareQuery(query, Storage::EntityStore::Ptr(&mEntityStore, [](Storage::EntityStore *){}));
     auto resultSet = preparedQuery->execute();
 
     SinkTrace() << "Filtered set retrieved. " << Log::TraceTime(time.elapsed());
     auto replayedEntities = replaySet(resultSet, offset, batchsize, callback);
 
     SinkTrace() << "Initial query took: " << Log::TraceTime(time.elapsed());
-    return qMakePair(Sink::Storage::maxRevision(mTransaction), replayedEntities);
+    return qMakePair(mEntityStore.maxRevision(), replayedEntities);
 }
 
 template <class DomainType>
@@ -174,14 +169,14 @@ QPair<qint64, qint64> EntityReader<DomainType>::executeIncrementalQuery(const Si
     time.start();
     const qint64 baseRevision = lastRevision + 1;
 
-    auto preparedQuery = ApplicationDomain::TypeImplementation<DomainType>::prepareQuery(query, mTransaction);
+    auto preparedQuery = ApplicationDomain::TypeImplementation<DomainType>::prepareQuery(query, Storage::EntityStore::Ptr(&mEntityStore, [](Storage::EntityStore *){}));
     auto resultSet = preparedQuery->update(baseRevision);
 
     SinkTrace() << "Filtered set retrieved. " << Log::TraceTime(time.elapsed());
     auto replayedEntities = replaySet(resultSet, 0, 0, callback);
 
     SinkTrace() << "Incremental query took: " << Log::TraceTime(time.elapsed());
-    return qMakePair(Sink::Storage::maxRevision(mTransaction), replayedEntities);
+    return qMakePair(mEntityStore.maxRevision(), replayedEntities);
 }
 
 template <class DomainType>
@@ -190,18 +185,18 @@ qint64 EntityReader<DomainType>::replaySet(ResultSet &resultSet, int offset, int
     SinkTrace() << "Skipping over " << offset << " results";
     resultSet.skip(offset);
     int counter = 0;
-    while (!batchSize || (counter < batchSize)) {
-        const bool ret =
-            resultSet.next([this, &counter, callback](const ResultSet::Result &result) -> bool {
-                counter++;
-                auto adaptor = mDomainTypeAdaptorFactory.createAdaptor(result.buffer.entity());
-                Q_ASSERT(adaptor);
-                return callback(QSharedPointer<DomainType>::create(mResourceInstanceIdentifier, result.uid, result.buffer.revision(), adaptor), result.operation, result.aggregateValues);
-            });
-        if (!ret) {
-            break;
-        }
-    };
+    /* while (!batchSize || (counter < batchSize)) { */
+    /*     const bool ret = */
+    /*         resultSet.next([this, &counter, callback](const ResultSet::Result &result) -> bool { */
+    /*             counter++; */
+    /*             auto adaptor = mResourceContext.adaptorFactory<DomainType>().createAdaptor(result.buffer.entity()); */
+    /*             Q_ASSERT(adaptor); */
+    /*             return callback(QSharedPointer<DomainType>::create(mResourceContext, result.uid, result.buffer.revision(), adaptor), result.operation, result.aggregateValues); */
+    /*         }); */
+    /*     if (!ret) { */
+    /*         break; */
+    /*     } */
+    /* }; */
     SinkTrace() << "Replayed " << counter << " results."
             << "Limit " << batchSize;
     return counter;