moved ResourceAccessFactory

3 files changed, 61 insertions, 57 deletions

diff --git a/common/facade.cpp b/common/facade.cpp
index 1b91ce4..1219887 100644
--- a/common/facade.cpp
+++ b/common/facade.cpp
@@ -32,63 +32,6 @@ using namespace Sink;
 #undef DEBUG_AREA
 #define DEBUG_AREA "client.facade"
 
-/**
- * A factory for resource access instances that caches the instance for some time.
- * 
- * This avoids constantly recreating connections, and should allow a single process to have one connection per resource.
- */
-class ResourceAccessFactory {
-public:
-    static ResourceAccessFactory &instance()
-    {
-        static ResourceAccessFactory *instance = 0;
-        if (!instance) {
-            instance = new ResourceAccessFactory;
-        }
-        return *instance;
-    }
-
-    Sink::ResourceAccess::Ptr getAccess(const QByteArray &instanceIdentifier)
-    {
-        if (!mCache.contains(instanceIdentifier)) {
-            //Reuse the pointer if something else kept the resourceaccess alive
-            if (mWeakCache.contains(instanceIdentifier)) {
-                auto sharedPointer = mWeakCache.value(instanceIdentifier).toStrongRef();
-                if (sharedPointer) {
-                    mCache.insert(instanceIdentifier, sharedPointer);
-                }
-            }
-            if (!mCache.contains(instanceIdentifier)) {
-                //Create a new instance if necessary
-                auto sharedPointer = Sink::ResourceAccess::Ptr::create(instanceIdentifier);
-                QObject::connect(sharedPointer.data(), &Sink::ResourceAccess::ready, sharedPointer.data(), [this, instanceIdentifier](bool ready) {
-                    if (!ready) {
-                        mCache.remove(instanceIdentifier);
-                    }
-                });
-                mCache.insert(instanceIdentifier, sharedPointer);
-                mWeakCache.insert(instanceIdentifier, sharedPointer);
-            }
-        }
-        if (!mTimer.contains(instanceIdentifier)) {
-            auto timer = new QTimer;
-            //Drop connection after 3 seconds (which is a random value)
-            QObject::connect(timer, &QTimer::timeout, timer, [this, instanceIdentifier]() {
-                mCache.remove(instanceIdentifier);
-            });
-            timer->setInterval(3000);
-            mTimer.insert(instanceIdentifier, timer);
-        }
-        auto timer = mTimer.value(instanceIdentifier);
-        timer->start();
-        return mCache.value(instanceIdentifier);
-    }
-
-    QHash<QByteArray, QWeakPointer<Sink::ResourceAccess> > mWeakCache;
-    QHash<QByteArray, Sink::ResourceAccess::Ptr> mCache;
-    QHash<QByteArray, QTimer*> mTimer;
-};
-
 template<class DomainType>
 GenericFacade<DomainType>::GenericFacade(const QByteArray &resourceIdentifier, const DomainTypeAdaptorFactoryInterface::Ptr &adaptorFactory , const QSharedPointer<Sink::ResourceAccessInterface> resourceAccess)
     : Sink::StoreFacade<DomainType>(),
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index 80d60e8..555d807 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -594,6 +594,51 @@ bool ResourceAccess::processMessageBuffer()
     return d->partialMessageBuffer.size() >= headerSize;
 }
 
+ResourceAccessFactory &ResourceAccessFactory::instance()
+{
+    static ResourceAccessFactory *instance = 0;
+    if (!instance) {
+        instance = new ResourceAccessFactory;
+    }
+    return *instance;
+}
+
+Sink::ResourceAccess::Ptr ResourceAccessFactory::getAccess(const QByteArray &instanceIdentifier)
+{
+    if (!mCache.contains(instanceIdentifier)) {
+        //Reuse the pointer if something else kept the resourceaccess alive
+        if (mWeakCache.contains(instanceIdentifier)) {
+            auto sharedPointer = mWeakCache.value(instanceIdentifier).toStrongRef();
+            if (sharedPointer) {
+                mCache.insert(instanceIdentifier, sharedPointer);
+            }
+        }
+        if (!mCache.contains(instanceIdentifier)) {
+            //Create a new instance if necessary
+            auto sharedPointer = Sink::ResourceAccess::Ptr::create(instanceIdentifier);
+            QObject::connect(sharedPointer.data(), &Sink::ResourceAccess::ready, sharedPointer.data(), [this, instanceIdentifier](bool ready) {
+                if (!ready) {
+                    mCache.remove(instanceIdentifier);
+                }
+            });
+            mCache.insert(instanceIdentifier, sharedPointer);
+            mWeakCache.insert(instanceIdentifier, sharedPointer);
+        }
+    }
+    if (!mTimer.contains(instanceIdentifier)) {
+        auto timer = new QTimer;
+        //Drop connection after 3 seconds (which is a random value)
+        QObject::connect(timer, &QTimer::timeout, timer, [this, instanceIdentifier]() {
+            mCache.remove(instanceIdentifier);
+        });
+        timer->setInterval(3000);
+        mTimer.insert(instanceIdentifier, timer);
+    }
+    auto timer = mTimer.value(instanceIdentifier);
+    timer->start();
+    return mCache.value(instanceIdentifier);
+}
+
 }
 
 #pragma clang diagnostic push
diff --git a/common/resourceaccess.h b/common/resourceaccess.h
index 4c10adb..3b03210 100644
--- a/common/resourceaccess.h
+++ b/common/resourceaccess.h
@@ -111,4 +111,20 @@ private:
     Private * const d;
 };
 
+/**
+ * A factory for resource access instances that caches the instance for some time.
+ * 
+ * This avoids constantly recreating connections, and should allow a single process to have one connection per resource.
+ */
+class ResourceAccessFactory {
+public:
+    static ResourceAccessFactory &instance();
+    Sink::ResourceAccess::Ptr getAccess(const QByteArray &instanceIdentifier);
+
+    QHash<QByteArray, QWeakPointer<Sink::ResourceAccess> > mWeakCache;
+    QHash<QByteArray, Sink::ResourceAccess::Ptr> mCache;
+    QHash<QByteArray, QTimer*> mTimer;
+};
+
+
 }