refactor event system

repertory/librepertory/include/events/event_system2.hpp

@@ -51,26 +51,26 @@ protected:
   ~event_system2() { stop(); }
 
 public:
-  class event_consumer2 final {
+  class event_consumer final {
   public:
-    explicit event_consumer2(std::function<void(const i_event &)> callback)
+    explicit event_consumer(std::function<void(const i_event &)> callback)
         : callback_(std::move(callback)) {
       event_system2::instance().attach(this);
     }
 
-    event_consumer2(std::string_view event_name,
+    event_consumer(std::string_view event_name,
-                    std::function<void(const i_event &)> callback)
+                   std::function<void(const i_event &)> callback)
         : callback_(std::move(callback)) {
       event_system2::instance().attach(event_name, this);
     }
 
-    ~event_consumer2() { event_system2::instance().release(this); }
+    ~event_consumer() { event_system2::instance().release(this); }
 
   public:
-    event_consumer2(const event_consumer2 &) = delete;
+    event_consumer(const event_consumer &) = delete;
-    event_consumer2(event_consumer2 &&) = delete;
+    event_consumer(event_consumer &&) = delete;
-    auto operator=(const event_consumer2 &) -> event_consumer2 & = delete;
+    auto operator=(const event_consumer &) -> event_consumer & = delete;
-    auto operator=(event_consumer2 &&) -> event_consumer2 & = delete;
+    auto operator=(event_consumer &&) -> event_consumer & = delete;
 
   private:
     std::function<void(const i_event &)> callback_;
@@ -86,7 +86,7 @@ public:
   [[nodiscard]] static auto instance() -> event_system2 &;
 
 private:
-  std::unordered_map<std::string, std::deque<event_consumer2 *>>
+  std::unordered_map<std::string, std::deque<event_consumer *>>
       event_consumers_;
   std::recursive_mutex consumer_mutex_;
   std::vector<std::shared_ptr<i_event>> event_list_;
@@ -104,42 +104,41 @@ private:
   void queue_event(std::shared_ptr<i_event> evt);
 
 public:
-  void attach(event_consumer2 *consumer);
+  void attach(event_consumer *consumer);
 
-  void attach(std::string_view event_name, event_consumer2 *consumer);
+  void attach(std::string_view event_name, event_consumer *consumer);
 
   template <typename evt_t, typename... arg_t> void raise(arg_t &&...args) {
     queue_event(std::make_shared<evt_t>(std::forward<arg_t>(args)...));
   }
 
-  void release(event_consumer2 *consumer);
+  void release(event_consumer *consumer);
 
   void start();
 
   void stop();
 };
 
-using event_consumer2 = event_system2::event_consumer2;
+using event_consumer = event_system2::event_consumer;
-using event_consumer = event_system2::event_consumer2;
 
 #define E_CONSUMER2()                                                          \
 private:                                                                       \
-  std::vector<std::shared_ptr<repertory::event_consumer2>> event_consumers2_
+  std::vector<std::shared_ptr<repertory::event_consumer>> event_consumers2_
 
 #define E_CONSUMER2_RELEASE() event_consumers2_.clear()
 
 #define E_SUBSCRIBE2(name, callback)                                           \
-  event_consumers2_.emplace_back(std::make_shared<repertory::event_consumer2>( \
+  event_consumers2_.emplace_back(std::make_shared<repertory::event_consumer>(  \
       #name, [this](const i_event &evt) { callback(evt); }))
 
 #define E_SUBSCRIBE2_EXACT(name, callback)                                     \
-  event_consumers2_.emplace_back(std::make_shared<repertory::event_consumer2>( \
+  event_consumers2_.emplace_back(std::make_shared<repertory::event_consumer>(  \
       #name, [this](const i_event &evt) {                                      \
         callback(dynamic_cast<const name &>(evt));                             \
       }))
 
 #define E_SUBSCRIBE2_ALL(callback)                                             \
-  event_consumers2_.emplace_back(std::make_shared<repertory::event_consumer2>( \
+  event_consumers2_.emplace_back(std::make_shared<repertory::event_consumer>(  \
       [this](const i_event &evt) { callback(evt); }))
 } // namespace repertory
 

repertory/librepertory/src/events/event_system2.cpp

@@ -30,13 +30,13 @@ event_system2 event_system2::instance_{};
 
 auto event_system2::instance() -> event_system2 & { return instance_; }
 
-void event_system2::attach(event_consumer2 *consumer) {
+void event_system2::attach(event_consumer *consumer) {
   recur_mutex_lock lock(consumer_mutex_);
   event_consumers_[""].push_back(consumer);
 }
 
 void event_system2::attach(std::string_view event_name,
-                           event_consumer2 *consumer) {
+                           event_consumer *consumer) {
   recur_mutex_lock lock(consumer_mutex_);
   event_consumers_[std::string{event_name}].push_back(consumer);
 }
@@ -113,7 +113,7 @@ void event_system2::queue_event(std::shared_ptr<i_event> evt) {
   }
 }
 
-void event_system2::release(event_consumer2 *consumer) {
+void event_system2::release(event_consumer *consumer) {
   recur_mutex_lock lock(consumer_mutex_);
   auto iter =
       std::ranges::find_if(event_consumers_, [&consumer](auto &&item) -> bool {