add new strucn event

src/event/api.hpp

@@ -5,15 +5,14 @@
 namespace VE
 {
   template <typename T>
-  void CONNECT(T* obj) 
+  std::string CONNECT(T* obj) 
   {
-    event_manager::instance().connect(obj, &T::on_event);
+    return event_manager::instance().connect(obj, &T::on_event);
   }
 
-  template <typename T>
-  void DISCONNECT(T* obj) 
+  inline void DISCONNECT(std::string key) 
   {
-    event_manager::instance().disconnect(obj, &T::on_event);
+    event_manager::instance().disconnect(key);
   }
 
   template <typename TYPE, typename DATA>

src/event/event_manager.hpp

@@ -1,53 +1,36 @@
 #pragma once
 
-#include <functional>
-#include <algorithm>
 #include <hack/patterns/singleton.hpp>
 #include <hack/logger/logger.hpp>
+#include <hack/security/uuid.hpp>
 
 #include "event.hpp"
+#include "utils/using.hpp"
 
 namespace VE
 {
   struct event_manager : public hack::patterns::singleton<event_manager>
   {
-    struct event_handler 
-    {
-      std::function<void(event)> m_func;
-      void* m_obj;
-      void* m_func_ptr;
-    };
-
-    std::vector<event_handler> m_funcs;
+    std::map<std::string, event_fn<event>> m_funcs;
 
     template<typename T>
-    void connect(T* obj, void (T::*method)(event)) 
+    std::string connect(T* obj, void (T::*method)(event)) 
     {
-      event_handler handler;
-      handler.m_func = std::bind(method, obj, std::placeholders::_1);
-      handler.m_obj = obj;
-      m_funcs.push_back(handler);
+      std::string key = hack::security::generate_uuid();
+      m_funcs[key] = std::bind(method, obj, std::placeholders::_1);
+      return key;
     }
-    
-    template<typename T>
-    void disconnect(T* obj, void (T::*method)(event)) 
+
+    void disconnect(std::string key) 
     {
-      m_funcs.erase(std::remove_if(m_funcs.begin(), m_funcs.end(),
-        [obj](const event_handler& handler) {
-          return handler.m_obj == obj;
-        }),
-        m_funcs.end()
-      );
+      m_funcs.erase(key);
     }
 
     void emit(event e)
     {
       try
       {
-        for (std::size_t i = 0; i < m_funcs.size(); ++i)
-        {
-          m_funcs[i].m_func(e);
-        }
+        for(auto [key, f] : m_funcs) m_funcs[key](e);
       }
       catch(const std::exception& ex)
       {