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, 4 insertions, 3 deletions

diff --git a/common/facadefactory.h b/common/facadefactory.h
index 7313970..8d41705 100644
--- a/common/facadefactory.h
+++ b/common/facadefactory.h
@@ -29,6 +29,7 @@
 
 #include "facadeinterface.h"
 #include "applicationdomaintype.h"
+#include "resourcecontext.h"
 #include "log.h"
 
 namespace Sink {
@@ -41,7 +42,7 @@ namespace Sink {
 class SINK_EXPORT FacadeFactory
 {
 public:
-    typedef std::function<std::shared_ptr<void>(const QByteArray &)> FactoryFunction;
+    typedef std::function<std::shared_ptr<void>(const ResourceContext &)> FactoryFunction;
 
     void registerStaticFacades();
 
@@ -52,13 +53,13 @@ public:
     template <class DomainType, class Facade>
     void registerFacade(const QByteArray &resource)
     {
-        registerFacade(resource, [](const QByteArray &instanceIdentifier) { return std::make_shared<Facade>(instanceIdentifier); }, ApplicationDomain::getTypeName<DomainType>());
+        registerFacade(resource, [](const ResourceContext &context) { return std::make_shared<Facade>(context); }, ApplicationDomain::getTypeName<DomainType>());
     }
 
     template <class DomainType, class Facade>
     void registerFacade()
     {
-        registerFacade(QByteArray(), [](const QByteArray &) { return std::make_shared<Facade>(); }, ApplicationDomain::getTypeName<DomainType>());
+        registerFacade(QByteArray(), [](const ResourceContext &) { return std::make_shared<Facade>(); }, ApplicationDomain::getTypeName<DomainType>());
     }
 
     /*