meta on_change, factory/cache now has metadata, sg.json update

Author: flipcoder

include/kit/cache/cache.h

@@ -7,18 +7,26 @@
 #include "../kit.h"
 #include "icache.h"
 
-template<class Class, class T>
+template<class Class, class T, class Mutex=kit::optional_mutex<std::recursive_mutex>>
 class Cache:
-    public Factory<Class, std::tuple<T, ICache*>>,
+    public Factory<Class, std::tuple<T, ICache*>, std::string, Mutex>,
     public ICache,
-    virtual public kit::mutexed<std::recursive_mutex>
+    virtual public kit::mutexed<Mutex>
 {
     public:
 
+        Cache() = default;
+        Cache(std::string fn):
+            Factory<Class, std::tuple<T, ICache*>>(fn)
+        {}
+        Cache(std::shared_ptr<Meta> cfg):
+            Factory<Class, std::tuple<T, ICache*>>(cfg)
+        {}
+        
         virtual ~Cache() {}
 
         virtual void optimize() override {
-            auto l = lock();
+            auto l = this->lock();
             for(auto itr = m_Resources.begin();
                 itr != m_Resources.end();)
             {
@@ -30,7 +38,7 @@ class Cache:
         }
 
         virtual std::shared_ptr<Class> cache_raw(const T& arg) {
-            auto l = lock();
+            auto l = this->lock();
             try{
                 return m_Resources.at(arg);
             }catch(const std::out_of_range&){
@@ -43,7 +51,7 @@ class Cache:
         }
 
         virtual std::shared_ptr<Class> cache(T arg) {
-            auto l = lock();
+            auto l = this->lock();
             if(m_Transformer)
                 arg = m_Transformer(arg);
             return cache_raw(arg);
@@ -55,7 +63,7 @@ class Cache:
 
         template<class Cast>
         std::shared_ptr<Cast> cache_as(T arg) {
-            auto l = lock();
+            auto l = this->lock();
             if(m_Transformer)
                 arg = m_Transformer(arg);
             std::shared_ptr<Cast> p;
@@ -76,24 +84,24 @@ class Cache:
         }
 
         virtual size_t size() const override {
-            auto l = lock();
+            auto l = this->lock();
             return m_Resources.size();
         }
         virtual bool empty() const override {
-            auto l = lock();
+            auto l = this->lock();
             return m_Resources.empty();
         }
 
         virtual void clear() override {
-            auto l = lock();
+            auto l = this->lock();
             m_Resources.clear();
         }
 
         T transform(const T& t){
             return m_Transformer(t);
         }
         void register_transformer(std::function<T(const T&)> f) {
-            auto l = lock();
+            auto l = this->lock();
             m_Transformer=f;
         }
 

include/kit/factory/factory.h

@@ -12,16 +12,22 @@
 #include <limits>
 #include "ifactory.h"
 #include "../kit.h"
+#include "../meta/meta.h"
 
 // TODO: add some way to have resolvers pass data into constructor instead
 //   of relying on unchangable ctor parameters (hmm...)
 // TODO: or how about add second callback for after the ctor (?)
 //   Let's use signals :D
 
-template<class Class, class T, class ClassName=std::string>
+template<
+    class Class,
+    class T,
+    class ClassName=std::string,
+    class Mutex=kit::optional_mutex<std::recursive_mutex>
+>
 class Factory:
     public IFactory,
-    virtual public kit::mutexed<std::recursive_mutex>
+    virtual public kit::mutexed<Mutex>
 {
     private:
 
@@ -44,13 +50,27 @@ class Factory:
 
         std::function<unsigned(const T&)> m_Resolver;
         std::function<T(const T&)> m_Transformer;
+        std::shared_ptr<MetaBase<Mutex>> m_pConfig;
 
     public:
 
+        Factory():
+            m_pConfig(std::make_shared<MetaBase<Mutex>>())
+        {}
+        Factory(std::string fn):
+            m_pConfig(std::make_shared<MetaBase<Mutex>>(fn))
+        {}
+        Factory(std::shared_ptr<Meta> cfg):
+            m_pConfig(std::make_shared<MetaBase<Mutex>>(cfg))
+        {}
+
+        std::shared_ptr<MetaBase<Mutex>> config() { return m_pConfig; }
+        std::shared_ptr<const MetaBase<Mutex>> config() const { return m_pConfig; }
+        
         virtual ~Factory() {}
 
         bool empty() const {
-            auto l = lock();
+            auto l = this->lock();
             return m_Classes.empty();
         }
 
@@ -62,7 +82,7 @@ class Factory:
         ) {
             // bind subclass's make_shared() to functor and store it in m_Classes list
             // TODO: exceptions?
-            auto l = lock();
+            auto l = this->lock();
 
             const size_t size = m_Classes.size();
             if(id == std::numeric_limits<unsigned>::max()) // don't care about class ID
@@ -92,12 +112,12 @@ class Factory:
         }
 
         void register_resolver(std::function<unsigned(const T&)> func) {
-            auto l = lock();
+            auto l = this->lock();
             m_Resolver = func;
         }
 
         unsigned class_id(ClassName name) const {
-            auto l = lock();
+            auto l = this->lock();
             try{
                 return m_ClassNames.at(name);
             } catch(const std::out_of_range&) {}
@@ -108,14 +128,14 @@ class Factory:
         }
 
         std::shared_ptr<Class> create(unsigned id, T args) const {
-            auto l = lock();
+            auto l = this->lock();
             if(m_Transformer)
                 args = m_Transformer(args);
             return m_Classes.at(id)(args);
         }
 
         std::shared_ptr<Class> create(T args) const {
-            auto l = lock();
+            auto l = this->lock();
             if(m_Transformer)
                 args = m_Transformer(args);
             unsigned id = m_Resolver(args);
@@ -132,13 +152,22 @@ class Factory:
         }
 
         void register_transformer(std::function<T(const T&)> f) {
-            auto l = lock();
+            auto l = this->lock();
             m_Transformer=f;
         }
 
         T transform(const T& t){
             return m_Transformer(t);
         }
+        
+        void share_config(std::shared_ptr<MetaBase<Mutex>> cfg){
+            auto l = this->lock();
+            m_pConfig = cfg;
+        }
+        std::shared_ptr<MetaBase<Mutex>> share_config() {
+            auto l = this->lock();
+            return m_pConfig;
+        }
 
         //std::vector<std::shared_ptr<Class>> create_all(
         //    const std::vector<T>& object_list

include/kit/kit.h

@@ -133,6 +133,25 @@ namespace kit
         void unlock() {}
     };
 
+    template<class Mutex=std::mutex>
+    struct optional_mutex
+    {
+        void lock() {
+            if(mutex)
+                mutex->lock();
+        }
+        bool try_lock() {
+            if(mutex)
+                return mutex->try_lock();
+            return true;
+        }
+        void unlock() {
+            if(mutex)
+                mutex->unlock();
+        }
+        std::shared_ptr<Mutex> mutex = std::make_shared<Mutex>();
+    };
+    
     template<class Mutex=std::mutex>
     class mutexed
     {
@@ -751,8 +770,9 @@ namespace kit
     template<class T>
     T safe_ptr(T ptr)
     {
-        if(ptr == nullptr)
+        if(ptr == nullptr){
             throw null_ptr_exception();
+        }
         return ptr;
     }