backend: c++17pilled

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;
+            auto event = (mst::event::Event*)events[i].data.ptr;
-
+            switch (event->data.index()) {
-            switch (event->variant) {
+                case 0: {
-                case event::Server: {
+                    auto& ref
-                    auto ptr = (mst::Server*)event->data;
+                        = std::get<std::unique_ptr<mst::Server>>(event->data);
-                    auto res = ptr->wake(*this);
+                    auto res = ref->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();
                     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();
             }
         }
     }

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 {
+#include <variant>
-enum Variant { Server, Client };
+#include <vector>
-struct Event {
-    Variant variant;
-    int fd;
-    void* data;
-};
 
-template <typename Data> auto make_event(Variant variant, Data data) -> Event*
+namespace mst {
-{
+class Server;
-    auto event = (Event*)malloc(sizeof(Event));
+class Client;
-    auto ptr = (Data*)std::malloc(sizeof(Data));
+namespace event {
-    *ptr = data;
+    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,
+        return std::make_unique<Event>(std::make_unique<Data>(std::move(data)));
-            .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 { };
     }
-    static auto create() -> Result<Manager>;
 
-private:
+    class Manager {
-    int epoll_fd;
+    public:
-    Manager(int epoll_fd)
+        auto start() -> Result<void>;
-        : epoll_fd(epoll_fd) { };
+        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) { };
+    };
+}
 }

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(
+    auto res
-        event::Client, mst::Client(*this, connection), connection.fd);
+        = mgr.register_event(mst::Client(*this, connection), connection.fd);
 
     if (!res) {
         return std::unexpected(res.error());

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>;