Prepare files for public release

include/util/Event.h

@@ -0,0 +1,50 @@
+
+#ifndef CONTROL_EVENT_H
+#define CONTROL_EVENT_H
+
+#include <functional>
+
+class Event;
+
+class CallbackHandle {
+  public:
+    CallbackHandle(Event *evt, int id) : evt(evt), id(id) {
+    }
+    ~CallbackHandle();
+
+  private:
+    Event *evt;
+    int id;
+};
+
+class Event {
+  public:
+    using Callback = std::function<void()>;
+
+    CallbackHandle addListener(Callback cb) {
+        int id = nextId++;
+        callbacks[id] = std::move(cb);
+        return CallbackHandle(this, id);
+    }
+
+    void remove(int id) {
+        callbacks.erase(id);
+    }
+
+    void fire() {
+        for (auto &kv : callbacks)
+            kv.second();
+    }
+
+  private:
+    friend class CallbackHandle;
+    std::unordered_map<int, Callback> callbacks;
+    int nextId = 0;
+};
+
+CallbackHandle::~CallbackHandle() {
+    if (evt)
+        evt->remove(id);
+}
+
+#endif // CONTROL_EVENT_H

include/util/Map.h

@@ -0,0 +1,18 @@
+
+#ifndef CONTROL_MAP_H
+#define CONTROL_MAP_H
+
+#include <unordered_map>
+#include <vector>
+
+template <typename K, typename V, typename H>
+std::vector<V> map_to_values(const std::unordered_map<K, V, H> &map) {
+    std::vector<V> out;
+    out.reserve(map.size());
+    for (auto const &[key, value] : map) {
+        out.push_back(value);
+    }
+    return out;
+}
+
+#endif // CONTROL_MAP_H

include/util/PairHash.h

@@ -0,0 +1,14 @@
+
+#ifndef CONTROL_PAIRHASH_H
+#define CONTROL_PAIRHASH_H
+
+#include <unordered_map>
+
+// Custom hash function for std::pair
+template <typename T> struct pair_hash {
+    std::size_t operator()(const std::pair<T, T> &p) const {
+        return std::hash<T>()(p.first) ^ (std::hash<T>()(p.second) << 1);
+    }
+};
+
+#endif // CONTROL_PAIRHASH_H

include/util/Variant.h

@@ -0,0 +1,13 @@
+
+#ifndef VARIANT_H
+#define VARIANT_H
+
+#include <variant> // NOLINT
+
+template <class... Ts> struct overloaded : Ts... {
+    using Ts::operator()...;
+};
+
+template <class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
+
+#endif // VARIANT_H