From 91759a4c9623a25f78dda17b392b9deec841685f Mon Sep 17 00:00:00 2001
From: patrick96 <p.ziegler96@gmail.com>
Date: Sun, 12 Sep 2021 16:25:23 +0200
Subject: [PATCH] Store all handles inside eventloop

This is needed because the handle's lifetime has to be at least the
lifetime of the eventloop since the eventloop requires the handle's
memory during shutdown (for closing the handles).
---
 include/components/controller.hpp |  2 +-
 include/components/eventloop.hpp  | 60 +++++++++++++++++++------------
 src/components/controller.cpp     | 14 +++-----
 3 files changed, 43 insertions(+), 33 deletions(-)

diff --git a/include/components/controller.hpp b/include/components/controller.hpp
index 323e59b5..58212c73 100644
--- a/include/components/controller.hpp
+++ b/include/components/controller.hpp
@@ -116,7 +116,7 @@ class controller : public signal_receiver<SIGN_PRIORITY_CONTROLLER, signals::eve
    * This handle is used to notify the eventloop of changes which are not otherwise covered by other handles.
    * E.g. click actions.
    */
-  std::unique_ptr<AsyncHandle> m_notifier{nullptr};
+  AsyncHandle_t m_notifier{nullptr};
 
   /**
    * Notification data for the controller.
diff --git a/include/components/eventloop.hpp b/include/components/eventloop.hpp
index dabea632..1394c5e7 100644
--- a/include/components/eventloop.hpp
+++ b/include/components/eventloop.hpp
@@ -148,6 +148,14 @@ struct AsyncHandle : public UVHandle<uv_async_t> {
   }
 };
 
+using SignalHandle_t = std::unique_ptr<SignalHandle>;
+using PollHandle_t = std::unique_ptr<PollHandle>;
+using FSEventHandle_t = std::unique_ptr<FSEventHandle>;
+using PipeHandle_t = std::unique_ptr<PipeHandle>;
+using TimerHandle_t = std::unique_ptr<TimerHandle>;
+// shared_ptr because we need a reference outside to call send
+using AsyncHandle_t = std::shared_ptr<AsyncHandle>;
+
 class eventloop {
  public:
   eventloop();
@@ -157,43 +165,51 @@ class eventloop {
 
   void stop();
 
-  /**
-   * TODO make protected
-   */
-  uv_loop_t* get() const {
-    return m_loop.get();
-  }
-
   void signal_handler(int signum, std::function<void(int)> fun) {
-    auto handle = std::make_unique<SignalHandle>(get(), fun);
-    handle->start(signum);
-    m_sig_handles.push_back(std::move(handle));
+    m_sig_handles.emplace_back(std::make_unique<SignalHandle>(get(), fun));
+    m_sig_handles.back()->start(signum);
   }
 
   void poll_handler(int events, int fd, std::function<void(int, int)> fun) {
-    auto handle = std::make_unique<PollHandle>(get(), fd, fun);
-    handle->start(events);
-    m_poll_handles.push_back(std::move(handle));
+    m_poll_handles.emplace_back(std::make_unique<PollHandle>(get(), fd, fun));
+    m_poll_handles.back()->start(events);
   }
 
   void fs_event_handler(const string& path, std::function<void(const char*, int, int)> fun) {
-    auto handle = std::make_unique<FSEventHandle>(get(), fun);
-    handle->start(path);
-    m_fs_event_handles.push_back(std::move(handle));
+    m_fs_event_handles.emplace_back(std::make_unique<FSEventHandle>(get(), fun));
+    m_fs_event_handles.back()->start(path);
+  }
+
+  void pipe_handle(int fd, std::function<void(const string)> fun) {
+    m_pipe_handles.emplace_back(std::make_unique<PipeHandle>(get(), fun));
+    m_pipe_handles.back()->start(fd);
+  }
+
+  void timer_handle(uint64_t timeout, uint64_t repeat, std::function<void(void)> fun) {
+    m_timer_handles.emplace_back(std::make_unique<TimerHandle>(get(), fun));
+    // Trigger a single screenshot after 3 seconds
+    m_timer_handles.back()->start(timeout, repeat);
+  }
+
+  AsyncHandle_t async_handle(std::function<void(void)> fun) {
+    m_async_handles.emplace_back(std::make_shared<AsyncHandle>(get(), fun));
+    return m_async_handles.back();
   }
 
  protected:
-  template <typename H, typename T, typename... Args, void (T::*F)(Args...)>
-  static void generic_cb(H* handle, Args&&... args) {
-    (static_cast<T*>(handle->data).*F)(std::forward<Args>(args)...);
+  uv_loop_t* get() const {
+    return m_loop.get();
   }
 
  private:
   std::unique_ptr<uv_loop_t> m_loop{nullptr};
 
-  vector<std::unique_ptr<SignalHandle>> m_sig_handles;
-  vector<std::unique_ptr<PollHandle>> m_poll_handles;
-  vector<std::unique_ptr<FSEventHandle>> m_fs_event_handles;
+  vector<SignalHandle_t> m_sig_handles;
+  vector<PollHandle_t> m_poll_handles;
+  vector<FSEventHandle_t> m_fs_event_handles;
+  vector<PipeHandle_t> m_pipe_handles;
+  vector<TimerHandle_t> m_timer_handles;
+  vector<AsyncHandle_t> m_async_handles;
 };
 
 POLYBAR_NS_END
diff --git a/src/components/controller.cpp b/src/components/controller.cpp
index e4fb8849..a19cbb5e 100644
--- a/src/components/controller.cpp
+++ b/src/components/controller.cpp
@@ -252,12 +252,8 @@ void controller::read_events(bool confwatch) {
     m_bar->start();
   }
 
-  auto ipc_handle = std::unique_ptr<PipeHandle>(nullptr);
-  auto screenshot_timer_handle = std::unique_ptr<TimerHandle>(nullptr);
-
   try {
     eloop = std::make_unique<eventloop>();
-    auto loop = eloop->get();
 
     eloop->poll_handler(
         UV_READABLE, m_connection.get_file_descriptor(), [this](int status, int events) { conn_cb(status, events); });
@@ -272,18 +268,16 @@ void controller::read_events(bool confwatch) {
     }
 
     if (m_ipc) {
-      ipc_handle = std::make_unique<PipeHandle>(loop, [this](const string payload) { ipc_cb(payload); });
-      ipc_handle->start(m_ipc->get_file_descriptor());
+      eloop->pipe_handle(m_ipc->get_file_descriptor(), [this](const string payload) { ipc_cb(payload); });
     }
 
-    m_notifier = std::make_unique<AsyncHandle>(loop, [this]() { notifier_handler(); });
-
     if (!m_snapshot_dst.empty()) {
-      screenshot_timer_handle = std::make_unique<TimerHandle>(loop, [this]() { screenshot_handler(); });
       // Trigger a single screenshot after 3 seconds
-      screenshot_timer_handle->start(3000, 0);
+      eloop->timer_handle(3000, 0, [this]() { screenshot_handler(); });
     }
 
+    m_notifier = eloop->async_handle([this]() { notifier_handler(); });
+
     m_eloop_ready.store(true);
 
     /*