From c5349719cdb4e1400733bd7e86957a3f7aace701 Mon Sep 17 00:00:00 2001
From: Theis Pieter Hollebeek <tphollebeek@gmail.com>
Date: Thu, 26 Mar 2026 11:58:43 +0100
Subject: [PATCH] backend: c++17pilled

---
 backend/src/event_loop.cpp | 37 +++++++++---------
 backend/src/event_loop.hpp | 78 ++++++++++++++++++++------------------
 backend/src/server.cpp     |  7 ++--
 backend/src/server.hpp     |  4 ++
 4 files changed, 68 insertions(+), 58 deletions(-)

diff --git a/backend/src/event_loop.cpp b/backend/src/event_loop.cpp
index ace6c90..2909ba9 100644
--- a/backend/src/event_loop.cpp
+++ b/backend/src/event_loop.cpp
@@ -1,11 +1,11 @@
 #include "event_loop.hpp"
 #include "errno_shim.hpp"
 #include "server.hpp"
-#include <print>
 #include <sys/epoll.h>
+#include <utility>
+#include <variant>
 
 namespace mst::event {
-
 auto Manager::start() -> Result<void>
 {
     epoll_event events[128] = { };
@@ -15,27 +15,28 @@ auto Manager::start() -> Result<void>
             return std::unexpected(errno_shim("could not poll"));
         }
         for (int i = 0; i < events_len; ++i) {
-            auto event = (event::Event*)events[i].data.ptr;
-
-            switch (event->variant) {
-                case event::Server: {
-                    auto ptr = (mst::Server*)event->data;
-                    auto res = ptr->wake(*this);
-                    if (!res) {
-                        return std::unexpected(res.error());
-                    }
-
-                    break;
-                }
-                case event::Client: {
-                    std::println("client call scheduled");
-                    auto ptr = (mst::Client*)event->data;
-                    auto res = ptr->wake();
+            auto event = (mst::event::Event*)events[i].data.ptr;
+            switch (event->data.index()) {
+                case 0: {
+                    auto& ref
+                        = std::get<std::unique_ptr<mst::Server>>(event->data);
+                    auto res = ref->wake(*this);
                     if (!res) {
                         return std::unexpected(res.error());
                     }
                     break;
                 }
+                case 1: {
+                    auto& ref
+                        = std::get<std::unique_ptr<mst::Client>>(event->data);
+                    auto res = ref->wake();
+                    if (!res) {
+                        return std::unexpected(res.error());
+                    }
+                    break;
+                }
+                default:
+                    std::unreachable();
             }
         }
     }
diff --git a/backend/src/event_loop.hpp b/backend/src/event_loop.hpp
index f2680de..69d1b53 100644
--- a/backend/src/event_loop.hpp
+++ b/backend/src/event_loop.hpp
@@ -1,47 +1,53 @@
 #pragma once
 #include "errno_shim.hpp"
 #include "result.hpp"
+#include "server.hpp"
+#include <memory>
 #include <sys/epoll.h>
-namespace mst::event {
-enum Variant { Server, Client };
-struct Event {
-    Variant variant;
-    int fd;
-    void* data;
-};
+#include <variant>
+#include <vector>
 
-template <typename Data> auto make_event(Variant variant, Data data) -> Event*
-{
-    auto event = (Event*)malloc(sizeof(Event));
-    auto ptr = (Data*)std::malloc(sizeof(Data));
-    *ptr = data;
+namespace mst {
+class Server;
+class Client;
+namespace event {
+    struct Event {
+        std::variant<std::unique_ptr<mst::Server>, std::unique_ptr<mst::Client>>
+            data;
+    };
 
-    event->variant = variant;
-    event->data = ptr;
-
-    return event;
-}
-
-class Manager {
-public:
-    auto start() -> Result<void>;
     template <typename Data>
-    auto register_event(Variant variant, Data data, int fd) -> Result<void>
+    auto make_event(Data&& data) -> std::unique_ptr<Event>
     {
-        auto poll_event = epoll_event { .events = EPOLLIN,
-            .data = { .ptr = make_event(variant, data) } };
-
-        if (::epoll_ctl(this->epoll_fd, EPOLL_CTL_ADD, fd, &poll_event) < 0) {
-            return std::unexpected(
-                errno_shim("could not add listener to epoll"));
-        }
-        return { };
+        return std::make_unique<Event>(std::make_unique<Data>(std::move(data)));
     }
-    static auto create() -> Result<Manager>;
 
-private:
-    int epoll_fd;
-    Manager(int epoll_fd)
-        : epoll_fd(epoll_fd) { };
-};
+    class Manager {
+    public:
+        auto start() -> Result<void>;
+        template <typename Data>
+        auto register_event(Data&& data, int fd) -> Result<void>
+        {
+
+            auto event = make_event(std::move(data));
+            this->events.emplace_back(std::move(event));
+            auto poll_event = epoll_event { .events = EPOLLIN,
+                .data = { .ptr = events.back().get() } };
+
+            if (::epoll_ctl(this->epoll_fd, EPOLL_CTL_ADD, fd, &poll_event)
+                < 0) {
+                return std::unexpected(
+                    errno_shim("could not add listener to epoll"));
+            }
+            return { };
+        }
+        static auto create() -> Result<Manager>;
+
+    private:
+        int epoll_fd;
+        std::vector<std::unique_ptr<Event>> events;
+        Manager(int epoll_fd)
+            : epoll_fd(epoll_fd) { };
+    };
+}
 }
diff --git a/backend/src/server.cpp b/backend/src/server.cpp
index c7f80db..d22336d 100644
--- a/backend/src/server.cpp
+++ b/backend/src/server.cpp
@@ -1,5 +1,4 @@
 #include "server.hpp"
-#include "errno_shim.hpp"
 #include "event_loop.hpp"
 #include <print>
 #include <sys/epoll.h>
@@ -30,7 +29,7 @@ auto Server::bind(
         return std::unexpected(x.error());
     }
     auto listener = x.value();
-    auto res = mgr.register_event(event::Server, Server(listener), listener.fd);
+    auto res = mgr.register_event(Server(listener), listener.fd);
     if (!res) {
         return std::unexpected(res.error());
     }
@@ -42,8 +41,8 @@ auto Server::wake(event::Manager& mgr) -> Result<void>
     auto x = this->listener.accept();
     auto connection = x.value();
 
-    auto res = mgr.register_event(
-        event::Client, mst::Client(*this, connection), connection.fd);
+    auto res
+        = mgr.register_event(mst::Client(*this, connection), connection.fd);
 
     if (!res) {
         return std::unexpected(res.error());
diff --git a/backend/src/server.hpp b/backend/src/server.hpp
index 6c07e4e..8d79f5d 100644
--- a/backend/src/server.hpp
+++ b/backend/src/server.hpp
@@ -5,6 +5,10 @@
 
 namespace mst {
 
+namespace event {
+    class Manager;
+}
+
 class Server {
 public:
     auto wake(mst::event::Manager& mgr) -> Result<void>;