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, 11 insertions, 19 deletions

diff --git a/common/entitystore.h b/common/entitystore.h
index 6bfe414..3d9ca36 100644
--- a/common/entitystore.h
+++ b/common/entitystore.h
@@ -20,50 +20,42 @@
 #pragma once
 
 #include "sink_export.h"
-#include <domainadaptor.h>
 
-#include "storage.h"
-#include "adaptorfactoryregistry.h"
-#include "entityreader.h"
+#include "storage/entitystore.h"
 
 namespace Sink {
 
 class SINK_EXPORT EntityStore
 {
 public:
-    EntityStore(const QByteArray &resourceType, const QByteArray &mResourceInstanceIdentifier, Sink::Storage::Transaction &transaction);
+    EntityStore(Storage::EntityStore &store);
 
     template<typename T>
     T read(const QByteArray &identifier) const
     {
-        EntityReader<T> reader(mResourceType, mResourceInstanceIdentifier, mTransaction);
-        return reader.read(identifier);
+        return store.readLatest<T>(identifier);
     }
 
     template<typename T>
     T readFromKey(const QByteArray &key) const
     {
-        EntityReader<T> reader(mResourceType, mResourceInstanceIdentifier, mTransaction);
-        return reader.readFromKey(key);
+        return store.readEntity<T>(key);
     }
 
     template<typename T>
     T readPrevious(const QByteArray &uid, qint64 revision) const
     {
-        EntityReader<T> reader(mResourceType, mResourceInstanceIdentifier, mTransaction);
-        return reader.readPrevious(uid, revision);
+        return store.readPrevious<T>(uid, revision);
     }
 
-    template<typename T>
-    EntityReader<T> reader()
-    {
-        return EntityReader<T>(mResourceType, mResourceInstanceIdentifier, mTransaction);
-    }
+    /* template<typename T> */
+    /* EntityReader<T> reader() */
+    /* { */
+    /*     return EntityReader<T>(mResourceType, mResourceInstanceIdentifier, mTransaction); */
+    /* } */
 
 private:
-    QByteArray mResourceType;
-    QByteArray mResourceInstanceIdentifier;
-    Sink::Storage::Transaction &mTransaction;
+    Sink::Storage::EntityStore &store;
 };
 
 }