Fixes on signals

1 files changed, 56 insertions, 52 deletions

diff --git a/engine/include/core/signal.hpp b/engine/include/core/signal.hpp
index be1644a..8a3d639 100644
--- a/engine/include/core/signal.hpp
+++ b/engine/include/core/signal.hpp
@@ -21,10 +21,22 @@ namespace flat
     {
     
     public:
+
+        struct package
+        {
+            package(void *data) : data(data) {}
+
+            template<class T>
+            T * get() {
+
+                return dynamic_cast<T>(data);
+            }
+
+            void * data;
+        };
     
         object * sender;
         package m_package;
-        priority_t prior;
     
         signal(     object * sender, 
                     const std::string& id = "", 
@@ -33,24 +45,47 @@ namespace flat
 
         /* Alias to flat::core::channel::emit() */
         bool emit(const std::string& channel) const;
+    };
+        
+    /* Listener class */
+    class listener
+    {
+    public:
 
-        struct package
+        using callback = std::function<void(const object*, signal::package)>;
+        using ptr = std::shared_ptr<listener>;
+
+        listener(callback m_callback, const std::initializer_list<std::string>& filters = {});
+        ~listener();
+
+        void add_filter(const std::string&);
+        void remove_filter(const std::string&);
+
+        bool connect(const std::string&);
+        bool disconnect(const std::string&);
+
+        void invoke(const signal&);
+
+        /* Allow to safely bind a functor */
+        template<typename R, typename T>
+        static ptr create(  R T::*mf,
+                            T& obj,
+                            const std::initializer_list<std::string>& filters = {})
         {
-            package(void *data) : data(data) {}
+            return std::make_shared<listener>(std::bind(mf, obj), filters);
+        }
 
-            template<class T>
-            T * get() {
+    private:
 
-                return dynamic_cast<T>(data);
-            }
+        callback m_callback;
 
-            void * data;
-        };
+        std::list<std::string> filters;
+    
+        bool check_in_filters(const std::string&) const;
     };
 
-    
     /* Channel class */
-    class channel : virtual public labelled
+    class channel : virtual public labelled, public std::enable_shared_from_this<channel>
     {
         /* Post processing signal stacking */
         queue<signal> stack;
@@ -63,65 +98,34 @@ namespace flat
         
         /* Channel mapping */
         static std::map<std::string, std::weak_ptr<channel>> channels;    
+
+        bool mapped;
      
     public:
+
+        using ptr = std::shared_ptr<channel>;
     
-        channel(const std::string& id = "", priority_t task_priority = priority_t::none);
+        channel(const std::string& id = "");
         ~channel();
 
-        void start();
+        void start(priority_t task_priority = priority_t::none);
         bool map();
     
         void emit(const signal&);
 
         bool connect(listener::ptr l);
         void disconnect(listener::ptr l);
+
+        bool connect(listener* l);
+        void disconnect(listener* l);
        
         static ptr find(const std::string&); 
 
-        static ptr create(const string& id, priority_t prior);
+        static ptr create(const std::string& id, priority_t prior);
     
         void check_and_call();
-
-        typedef shared_ptr<channel> ptr;
     };
-    
-    /* Listener class */
-    class listener
-    {
-        std::list<std::string> filters;
-    
-        bool check_in_filters(const std::string&) const;
-    
-        callback_t m_callback;
-    
-    public:
-    
-        listener(   callback_t m_callback,
-                    const std::initializer_list<std::string>& filters = {});
-    
-        ~listener();
 
-        void add_filter(const std::string&);
-        void remove_filter(const std::string&);
-
-        bool connect(const std::string&);
-        bool disconnect(const std::string&);
-
-        void invoke(const signal&);
-
-        /* Allow to safely bind a functor */
-        template<class T>
-        static ptr create(  const (T::*method(const object*, void*))& fct,
-                            T* obj,
-                            const std::initializer_list<std::string>& filters = {})
-        {
-            return new listener(std::bind(fct, ptr), filters);
-        }
-
-        typedef std::function<void(const object*, signal::package)> callback_t;
-        typedef shared_ptr<listener> ptr;
-    };
 
     }
 }