brenta: implemented signal manager

Author: San7o

TODO

@@ -1 +0,0 @@
-- implement signals for node scripts

external/tenno-tl

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+// Author:  Giovanni Santini
+// Mail:    giovanni.santini@proton.me
+// Github:  @San7o
+
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+#include <tenno/vector.hpp>
+
+namespace brenta
+{
+
+class SignalManager
+{
+public:
+  
+  using SignalId     = std::string;
+  using Message      = std::string;
+  using ConnectionId = int;
+  using Callback     = std::function<void(Message)>;
+
+  struct Event;
+  class  Subscription;
+
+  SignalManager()  = delete;
+  ~SignalManager() = delete;
+
+  static void emit(const Event& event);
+  
+  static Subscription subscribe(const SignalId& id, Callback callback);
+  static void unsubscribe(const Subscription &sub);
+
+  // Process all pending events
+  static void update();
+  
+private:
+
+  static tenno::vector<Event> pending_events;
+  static std::unordered_map<SignalId,
+                            tenno::vector<std::pair<ConnectionId,
+                                                    Callback>>> registry;
+  
+};
+
+struct SignalManager::Event
+{
+  SignalId id;
+  Message  message;
+};
+  
+class SignalManager::Subscription
+{
+public:
+
+  friend class SignalManager;
+  
+  Subscription() = delete;
+  ~Subscription();
+   
+private:
+
+  Subscription(SignalId signal_id, ConnectionId connection_id)
+    : signal_id(signal_id), connection_id(connection_id) {}
+
+  SignalId       signal_id;
+  ConnectionId   connection_id;
+};
+
+  
+} // namespace brenta

include/brenta/signal_manager.hpp

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: MIT
+// Author:  Giovanni Santini
+// Mail:    giovanni.santini@proton.me
+// Github:  @San7o
+
+#include <brenta/signal_manager.hpp>
+
+using namespace brenta;
+
+//
+// Static storage
+//
+
+tenno::vector<SignalManager::Event> SignalManager::pending_events;
+std::unordered_map<SignalManager::SignalId,
+                   tenno::vector<std::pair<SignalManager::ConnectionId,
+                                           SignalManager::Callback>>>
+SignalManager::registry;
+
+//
+// Member functions
+//
+
+void SignalManager::emit(const SignalManager::Event &event)
+{
+  SignalManager::pending_events.push_back(event);
+}
+
+SignalManager::Subscription
+SignalManager::subscribe(const SignalManager::SignalId &id,
+                         SignalManager::Callback callback)
+{
+  static ConnectionId connection_id = 0;
+  connection_id++;
+  
+  SignalManager::registry[id].push_back(std::make_tuple(connection_id, callback));
+  return Subscription(id, connection_id);
+}
+
+void SignalManager::unsubscribe(const SignalManager::Subscription &sub)
+{
+  auto& entries = SignalManager::registry[sub.signal_id];
+  for (auto it = entries.begin(); it != entries.end(); ++it)
+  {
+    if (std::get<0>(*it) == sub.connection_id)
+    {
+      entries.erase(it);
+      break;
+    }
+  }
+}
+
+void SignalManager::update()
+{
+  for (auto& event : SignalManager::pending_events)
+  {
+    if (!SignalManager::registry.contains(event.id)) continue;
+
+    for (auto& [_, callback] : SignalManager::registry[event.id])
+    {
+      callback(event.message);
+    }
+  }
+}
+  
+SignalManager::Subscription::~Subscription()
+{
+  if (this->connection_id == 0) return;
+  SignalManager::unsubscribe(*this);
+}