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, 68 insertions, 68 deletions

diff --git a/tests/storagetest.cpp b/tests/storagetest.cpp
index aa12ec1..5a517c7 100644
--- a/tests/storagetest.cpp
+++ b/tests/storagetest.cpp
@@ -21,14 +21,14 @@ private:
 
     void populate(int count)
     {
-        Sink::Storage storage(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = storage.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore storage(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = storage.createTransaction(Sink::Storage::DataStore::ReadWrite);
         for (int i = 0; i < count; i++) {
             // This should perhaps become an implementation detail of the db?
             if (i % 10000 == 0) {
                 if (i > 0) {
                     transaction.commit();
-                    transaction = storage.createTransaction(Sink::Storage::ReadWrite);
+                    transaction = storage.createTransaction(Sink::Storage::DataStore::ReadWrite);
                 }
             }
             transaction.openDatabase().write(keyPrefix + QByteArray::number(i), keyPrefix + QByteArray::number(i));
@@ -36,12 +36,12 @@ private:
         transaction.commit();
     }
 
-    bool verify(Sink::Storage &storage, int i)
+    bool verify(Sink::Storage::DataStore &storage, int i)
     {
         bool success = true;
         bool keyMatch = true;
         const auto reference = keyPrefix + QByteArray::number(i);
-        storage.createTransaction(Sink::Storage::ReadOnly)
+        storage.createTransaction(Sink::Storage::DataStore::ReadOnly)
             .openDatabase()
             .scan(keyPrefix + QByteArray::number(i),
                 [&keyMatch, &reference](const QByteArray &key, const QByteArray &value) -> bool {
@@ -51,7 +51,7 @@ private:
                     }
                     return keyMatch;
                 },
-                [&success](const Sink::Storage::Error &error) {
+                [&success](const Sink::Storage::DataStore::Error &error) {
                     qDebug() << error.message;
                     success = false;
                 });
@@ -63,20 +63,20 @@ private slots:
     {
         testDataPath = "./testdb";
         dbName = "test";
-        Sink::Storage storage(testDataPath, dbName);
+        Sink::Storage::DataStore storage(testDataPath, dbName);
         storage.removeFromDisk();
     }
 
     void cleanup()
     {
-        Sink::Storage storage(testDataPath, dbName);
+        Sink::Storage::DataStore storage(testDataPath, dbName);
         storage.removeFromDisk();
     }
 
     void testCleanup()
     {
         populate(1);
-        Sink::Storage storage(testDataPath, dbName);
+        Sink::Storage::DataStore storage(testDataPath, dbName);
         storage.removeFromDisk();
         QFileInfo info(testDataPath + "/" + dbName);
         QVERIFY(!info.exists());
@@ -90,7 +90,7 @@ private slots:
 
         // ensure we can read everything back correctly
         {
-            Sink::Storage storage(testDataPath, dbName);
+            Sink::Storage::DataStore storage(testDataPath, dbName);
             for (int i = 0; i < count; i++) {
                 QVERIFY(verify(storage, i));
             }
@@ -105,8 +105,8 @@ private slots:
         // ensure we can scan for values
         {
             int hit = 0;
-            Sink::Storage store(testDataPath, dbName);
-            store.createTransaction(Sink::Storage::ReadOnly)
+            Sink::Storage::DataStore store(testDataPath, dbName);
+            store.createTransaction(Sink::Storage::DataStore::ReadOnly)
                 .openDatabase()
                 .scan("", [&](const QByteArray &key, const QByteArray &value) -> bool {
                     if (key == "key50") {
@@ -121,8 +121,8 @@ private slots:
         {
             int hit = 0;
             bool foundInvalidValue = false;
-            Sink::Storage store(testDataPath, dbName);
-            store.createTransaction(Sink::Storage::ReadOnly)
+            Sink::Storage::DataStore store(testDataPath, dbName);
+            store.createTransaction(Sink::Storage::DataStore::ReadOnly)
                 .openDatabase()
                 .scan("key50", [&](const QByteArray &key, const QByteArray &value) -> bool {
                     if (key != "key50") {
@@ -139,10 +139,10 @@ private slots:
     void testNestedOperations()
     {
         populate(3);
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         transaction.openDatabase().scan("key1", [&](const QByteArray &key, const QByteArray &value) -> bool {
-            transaction.openDatabase().remove(key, [](const Sink::Storage::Error &) { QVERIFY(false); });
+            transaction.openDatabase().remove(key, [](const Sink::Storage::DataStore::Error &) { QVERIFY(false); });
             return false;
         });
     }
@@ -150,11 +150,11 @@ private slots:
     void testNestedTransactions()
     {
         populate(3);
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        store.createTransaction(Sink::Storage::ReadOnly)
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        store.createTransaction(Sink::Storage::DataStore::ReadOnly)
             .openDatabase()
             .scan("key1", [&](const QByteArray &key, const QByteArray &value) -> bool {
-                store.createTransaction(Sink::Storage::ReadWrite).openDatabase().remove(key, [](const Sink::Storage::Error &) { QVERIFY(false); });
+                store.createTransaction(Sink::Storage::DataStore::ReadWrite).openDatabase().remove(key, [](const Sink::Storage::DataStore::Error &) { QVERIFY(false); });
                 return false;
             });
     }
@@ -163,9 +163,9 @@ private slots:
     {
         bool gotResult = false;
         bool gotError = false;
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadOnly);
-        auto db = transaction.openDatabase("default", [&](const Sink::Storage::Error &error) {
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadOnly);
+        auto db = transaction.openDatabase("default", [&](const Sink::Storage::DataStore::Error &error) {
             qDebug() << error.message;
             gotError = true;
         });
@@ -174,7 +174,7 @@ private slots:
                 gotResult = true;
                 return false;
             },
-            [&](const Sink::Storage::Error &error) {
+            [&](const Sink::Storage::DataStore::Error &error) {
                 qDebug() << error.message;
                 gotError = true;
             });
@@ -199,8 +199,8 @@ private slots:
             const int concurrencyLevel = 20;
             for (int num = 0; num < concurrencyLevel; num++) {
                 futures << QtConcurrent::run([this, count, &error]() {
-                    Sink::Storage storage(testDataPath, dbName, Sink::Storage::ReadOnly);
-                    Sink::Storage storage2(testDataPath, dbName + "2", Sink::Storage::ReadOnly);
+                    Sink::Storage::DataStore storage(testDataPath, dbName, Sink::Storage::DataStore::ReadOnly);
+                    Sink::Storage::DataStore storage2(testDataPath, dbName + "2", Sink::Storage::DataStore::ReadOnly);
                     for (int i = 0; i < count; i++) {
                         if (!verify(storage, i)) {
                             error = true;
@@ -216,9 +216,9 @@ private slots:
         }
 
         {
-            Sink::Storage storage(testDataPath, dbName);
+            Sink::Storage::DataStore storage(testDataPath, dbName);
             storage.removeFromDisk();
-            Sink::Storage storage2(testDataPath, dbName + "2");
+            Sink::Storage::DataStore storage2(testDataPath, dbName + "2");
             storage2.removeFromDisk();
         }
     }
@@ -227,8 +227,8 @@ private slots:
     {
         bool gotResult = false;
         bool gotError = false;
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         auto db = transaction.openDatabase("default", nullptr, false);
         db.write("key", "value");
         db.write("key", "value");
@@ -238,7 +238,7 @@ private slots:
                 gotResult = true;
                 return true;
             },
-            [&](const Sink::Storage::Error &error) {
+            [&](const Sink::Storage::DataStore::Error &error) {
                 qDebug() << error.message;
                 gotError = true;
             });
@@ -252,8 +252,8 @@ private slots:
     {
         bool gotResult = false;
         bool gotError = false;
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         auto db = transaction.openDatabase("default", nullptr, true);
         db.write("key", "value1");
         db.write("key", "value2");
@@ -262,7 +262,7 @@ private slots:
                 gotResult = true;
                 return true;
             },
-            [&](const Sink::Storage::Error &error) {
+            [&](const Sink::Storage::DataStore::Error &error) {
                 qDebug() << error.message;
                 gotError = true;
             });
@@ -275,15 +275,15 @@ private slots:
     {
         bool gotResult = false;
         bool gotError = false;
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadOnly);
-        int numValues = store.createTransaction(Sink::Storage::ReadOnly)
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadOnly);
+        int numValues = store.createTransaction(Sink::Storage::DataStore::ReadOnly)
                             .openDatabase("test")
                             .scan("",
                                 [&](const QByteArray &key, const QByteArray &value) -> bool {
                                     gotResult = true;
                                     return false;
                                 },
-                                [&](const Sink::Storage::Error &error) {
+                                [&](const Sink::Storage::DataStore::Error &error) {
                                     qDebug() << error.message;
                                     gotError = true;
                                 });
@@ -295,10 +295,10 @@ private slots:
     void testWriteToNamedDb()
     {
         bool gotError = false;
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        store.createTransaction(Sink::Storage::ReadWrite)
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        store.createTransaction(Sink::Storage::DataStore::ReadWrite)
             .openDatabase("test")
-            .write("key1", "value1", [&](const Sink::Storage::Error &error) {
+            .write("key1", "value1", [&](const Sink::Storage::DataStore::Error &error) {
                 qDebug() << error.message;
                 gotError = true;
             });
@@ -308,10 +308,10 @@ private slots:
     void testWriteDuplicatesToNamedDb()
     {
         bool gotError = false;
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        store.createTransaction(Sink::Storage::ReadWrite)
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        store.createTransaction(Sink::Storage::DataStore::ReadWrite)
             .openDatabase("test", nullptr, true)
-            .write("key1", "value1", [&](const Sink::Storage::Error &error) {
+            .write("key1", "value1", [&](const Sink::Storage::DataStore::Error &error) {
                 qDebug() << error.message;
                 gotError = true;
             });
@@ -321,8 +321,8 @@ private slots:
     // By default we want only exact matches
     void testSubstringKeys()
     {
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         auto db = transaction.openDatabase("test", nullptr, true);
         db.write("sub", "value1");
         db.write("subsub", "value2");
@@ -333,8 +333,8 @@ private slots:
 
     void testFindSubstringKeys()
     {
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         auto db = transaction.openDatabase("test", nullptr, false);
         db.write("sub", "value1");
         db.write("subsub", "value2");
@@ -346,8 +346,8 @@ private slots:
 
     void testFindSubstringKeysWithDuplicatesEnabled()
     {
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         auto db = transaction.openDatabase("test", nullptr, true);
         db.write("sub", "value1");
         db.write("subsub", "value2");
@@ -359,8 +359,8 @@ private slots:
 
     void testKeySorting()
     {
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         auto db = transaction.openDatabase("test", nullptr, false);
         db.write("sub_2", "value2");
         db.write("sub_1", "value1");
@@ -380,8 +380,8 @@ private slots:
     // Ensure we don't retrieve a key that is greater than the current key. We only want equal keys.
     void testKeyRange()
     {
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         auto db = transaction.openDatabase("test", nullptr, true);
         db.write("sub1", "value1");
         int numValues = db.scan("sub", [&](const QByteArray &key, const QByteArray &value) -> bool { return true; });
@@ -391,8 +391,8 @@ private slots:
 
     void testFindLatest()
     {
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         auto db = transaction.openDatabase("test", nullptr, false);
         db.write("sub1", "value1");
         db.write("sub2", "value2");
@@ -406,8 +406,8 @@ private slots:
 
     void testFindLatestInSingle()
     {
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         auto db = transaction.openDatabase("test", nullptr, false);
         db.write("sub2", "value2");
         QByteArray result;
@@ -418,8 +418,8 @@ private slots:
 
     void testFindLast()
     {
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         auto db = transaction.openDatabase("test", nullptr, false);
         db.write("sub2", "value2");
         db.write("wub3", "value3");
@@ -431,23 +431,23 @@ private slots:
 
     void testRecordRevision()
     {
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
-        Sink::Storage::recordRevision(transaction, 1, "uid", "type");
-        QCOMPARE(Sink::Storage::getTypeFromRevision(transaction, 1), QByteArray("type"));
-        QCOMPARE(Sink::Storage::getUidFromRevision(transaction, 1), QByteArray("uid"));
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
+        Sink::Storage::DataStore::recordRevision(transaction, 1, "uid", "type");
+        QCOMPARE(Sink::Storage::DataStore::getTypeFromRevision(transaction, 1), QByteArray("type"));
+        QCOMPARE(Sink::Storage::DataStore::getUidFromRevision(transaction, 1), QByteArray("uid"));
     }
 
     void testRecordRevisionSorting()
     {
-        Sink::Storage store(testDataPath, dbName, Sink::Storage::ReadWrite);
-        auto transaction = store.createTransaction(Sink::Storage::ReadWrite);
+        Sink::Storage::DataStore store(testDataPath, dbName, Sink::Storage::DataStore::ReadWrite);
+        auto transaction = store.createTransaction(Sink::Storage::DataStore::ReadWrite);
         QByteArray result;
         auto db = transaction.openDatabase("test", nullptr, false);
         const auto uid = "{c5d06a9f-1534-4c52-b8ea-415db68bdadf}";
         //Ensure we can sort 1 and 10 properly (by default string comparison 10 comes before 6)
-        db.write(Sink::Storage::assembleKey(uid, 6), "value1");
-        db.write(Sink::Storage::assembleKey(uid, 10), "value2");
+        db.write(Sink::Storage::DataStore::assembleKey(uid, 6), "value1");
+        db.write(Sink::Storage::DataStore::assembleKey(uid, 10), "value2");
         db.findLatest(uid, [&](const QByteArray &key, const QByteArray &value) { result = value; });
         QCOMPARE(result, QByteArray("value2"));
     }