1 files changed, 39 insertions, 41 deletions

diff --git a/engine/signal.cpp b/engine/signal.cpp
index 7688785..512b456 100644
--- a/engine/signal.cpp
+++ b/engine/signal.cpp
@@ -7,17 +7,17 @@
 
 using namespace flat::core;
 
-std::map<std::string, std::weak_ptr<channel>> channel::channels;    
+std::map<std::string, std::weak_ptr<channel>> channel::m_channels;
 
-channel::channel(const std::string& id) : labelled(id), mapped(false)
+channel::channel(const std::string& id) : labelled(id), m_mapped(false)
 {
 }
 
 channel::~channel()
 {
     // by default it should be there
-    if (mapped)
-        channels.erase(label);
+    if (m_mapped)
+        m_channels.erase(label);
 }
 
 void channel::start(priority_t prior)
@@ -25,35 +25,34 @@ void channel::start(priority_t prior)
     npdebug("Starting channel: ", label);
 
     // Initialize task
-    checker = flat::main_job().delegate_task(&channel::check_and_call, this, prior);
+    m_checker = flat::main_job().delegate_task(&channel::check_and_call, this, prior);
 }
 
 bool channel::map()
 {
-    if (!mapped) {
+    if (!m_mapped) {
 
         channel::ptr other = channel::find(label);
 
         if (!other) {
-
-            channels.insert(std::pair<std::string, std::weak_ptr<channel>>(label, weak_from_this())); 
-            mapped = true;
+            m_channels.insert(std::pair<std::string, std::weak_ptr<channel>>(label, weak_from_this())); 
+            m_mapped = true;
         }
     }
 
-    return mapped;
+    return m_mapped;
 }
 
 void channel::emit(const signal& sig)
 {
-    stack.insert(sig);
+    m_stack.insert(sig);
     npdebug("Emitted signal: ", sig.label, " ", this);
 }
 
 bool channel::connect(listener::ptr l)
 {
     /* Control not to double */
-    for (auto lis : listeners)
+    for (auto lis : m_listeners)
     {
         auto pt = lis.lock();
 
@@ -61,16 +60,16 @@ bool channel::connect(listener::ptr l)
             return false;
     }
 
-    listeners.push_back(l);
+    m_listeners.push_back(l);
     return true;
 }
 
 void channel::disconnect(listener::ptr l)
 {
-    listeners.erase(
+    m_listeners.erase(
         std::remove_if(
-            listeners.begin(),
-            listeners.end(),
+            m_listeners.begin(),
+            m_listeners.end(),
             [&l](std::weak_ptr<listener> p){ 
                 listener::ptr pt = p.lock();
                 return pt.get() == l.get(); 
@@ -115,19 +114,18 @@ channel::ptr channel::create(const std::string& id, priority_t prior)
    
 channel::ptr channel::find(const std::string& id)
 {
+    // what about anonymous (unlabeled) channels?
     if (id.empty())
         return nullptr;
 
-    auto it = channels.find(id);
+    auto it = m_channels.find(id);
 
-    return (it == channels.end()) ? nullptr : (*it).second.lock();
+    return (it == m_channels.end()) ? nullptr : (*it).second.lock();
 }
 
-int step = 0;
-
 void channel::check_and_call()
 {
-    if (!stack.empty()) {
+    if (!m_stack.empty()) {
 
         npdebug("Signal detected: ", label, " ", this)
 
@@ -136,13 +134,13 @@ void channel::check_and_call()
         // TODO, maybe it exists pop
         /* for each listener_s, catch signal */
 
-        for (auto l : listeners)
+        for (auto l : m_listeners)
         {
             listener::ptr pt;
 
             if (pt = l.lock())
             {
-                for (const auto& sig : stack)
+                for (const auto& sig : m_stack)
                     pt->invoke(sig);
             }
             else
@@ -150,29 +148,29 @@ void channel::check_and_call()
         }
     
         /* Erase invalidated listeners */
-        listeners.erase(
+        m_listeners.erase(
             std::remove_if(
-                listeners.begin(),
-                listeners.end(),
+                m_listeners.begin(),
+                m_listeners.end(),
                 [](std::weak_ptr<listener> e) { return e.expired(); }
             )
         );
 
-        stack.clear(); // TODO not so efficient
+        m_stack.clear(); // TODO not so efficient
     }
 }
 
 
 /* signal class */
 
-signal::signal( object *sender, 
-                const std::string& id, 
-                void *data, 
-                priority_t priority)
+signal::signal(object *sender, 
+               const std::string& id, 
+               void *data, 
+               priority_t p)
 
     :   labelled(id, true), 
-        prioritized(priority),
-        sender(sender), 
+        prioritized(p),
+        m_sender(sender), 
         m_package(package(data))
 {
 }
@@ -193,9 +191,9 @@ bool signal::emit(const std::string& chan) const
 
 /* listener_s class */
 
-listener::listener(callback m_callback, const std::initializer_list<std::string>& filters)
+listener::listener(callback callback, const std::initializer_list<std::string>& filters)
 
-    : m_callback(m_callback), filters(filters)
+    : m_callback(callback), m_filters(filters)
 {
 
 }
@@ -206,7 +204,7 @@ listener::~listener()
 
 bool listener::check_in_filters(const std::string& filter) const
 {
-    for (const auto& f : filters)
+    for (const auto& f : m_filters)
     {
         if (filter == f)
             return true;
@@ -217,12 +215,12 @@ bool listener::check_in_filters(const std::string& filter) const
 
 void listener::add_filter(const std::string& f)
 {
-    filters.push_back(f);
+    m_filters.push_back(f);
 }
 
 void listener::remove_filter(const std::string& f)
 {
-    filters.remove(f);
+    m_filters.remove(f);
 }
 
 bool listener::connect(const std::string& chan)
@@ -247,8 +245,8 @@ bool listener::disconnect(const std::string& chan)
 
 void listener::invoke(const signal& sig)
 {
-    if (    (!sig.label.empty() && check_in_filters(sig.label)) || 
-            (sig.label.empty() && filters.empty()))
-        m_callback(sig.sender, sig.m_package);
+    if ((!sig.label.empty() && check_in_filters(sig.label)) || 
+        (sig.label.empty() && m_filters.empty()))
+        m_callback(sig.m_sender, sig.m_package);
 }