copying code over from alphane engine

2026-08-14 06:09:53 +00:00
parent 108341158e
commit 263b6da528
13 changed files with 1203 additions and 0 deletions
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <typeinfo>
+#include <vector>
+
+#include "util/logger.hpp"
+
+#define DEFAULT_DELEGATE_FUNCTOR_ALLOC 5
+
+namespace hep {
+
+class expired_weak_object : public std::runtime_error {
+ public:
+  explicit expired_weak_object(const std::string& message)
+      : std::runtime_error(message) {}
+};
+
+/**
+ * Creates a weak function that safely calls a method if the
+ * object is alive.
+ *
+ * @tparam O Class owning the method
+ * @tparam A Variadic template parameters for the method arguments
+ *
+ * @param method Pointer to the static method to be called
+ * @param obj Shared pointer to the object instance
+ * @returns std::function that calls method on obj if alive, or throws if
+ * expired
+ * @throws std::invalid_argument If obj is null.
+ * @throws expired_weak_object If the object has expired when called
+ *
+ * @note Could investigate removing throwing exceptions, and instead return a
+ * bool if the weak pointer is alive. This may improve performance
+ */
+template <class O, typename... A>
+std::function<void(A...)> createWeakFunction(void (O::*method)(A...),
+                                             std::shared_ptr<O> obj) {
+  if (!obj) { throw std::invalid_argument("method and obj must not be null"); }
+
+  std::weak_ptr<O> weakObj = obj;
+
+  return std::function<void(A...)>([method = std::move(method),
+                                    weakObj = std::move(weakObj)](A... args) {
+    if (auto lockedObj = weakObj.lock()) {
+      (lockedObj.get()->*method)(std::forward<A>(args)...);
+    } else {
+      throw expired_weak_object("Attempting to call function of a dead class");
+    }
+  });
+}
+
+template <typename... A>
+class Delegate {
+ public:
+  using Functor = std::function<void(A...)>;
+
+  Delegate() { this->functors.reserve(DEFAULT_DELEGATE_FUNCTOR_ALLOC); }
+
+  void add(const Functor& func) { functors.push_back(func); }
+
+  template <class O>
+  void addMethod(void (O::*memberFn)(A...), std::shared_ptr<O> obj) {
+    functors.push_back(createWeakFunction(memberFn, obj));
+  }
+
+  void clear() { this->functors.clear(); }
+
+  void invoke(A... args) {
+    if (this->functors.empty()) {
+      log::warning("invoking empty delegate");
+      return;
+    }
+
+    std::vector<size_t> deadFunctorIndexs;
+
+    for (size_t i = 0; i < functors.size(); i++) {
+      if (this->functors[i]) {
+        try {
+          this->functors[i](std::forward<A>(args)...);
+        } catch (const expired_weak_object& e) {
+          log::error("delegate invoke error: ", e.what());
+          deadFunctorIndexs.push_back(i);
+        }
+      }
+    }
+
+    for (auto it = deadFunctorIndexs.rbegin(); it != deadFunctorIndexs.rend();
+         ++it) {
+      functors.erase(functors.begin() + *it);
+    }
+  }
+
+  void operator=(Functor c) {
+    clear();
+
+    if (c != nullptr) { add(c); }
+  }
+
+  void operator+=(Functor c) { add(c); }
+
+  void operator()() { invoke(); }
+
+ private:
+  std::vector<Functor> functors;
+};
+
+}  // namespace hep