refactor

repertory/librepertory/include/events/t_event_system.hpp

@@ -29,6 +29,19 @@
 
 namespace repertory {
 template <typename event_type> class t_event_system final {
+private:
+  static constexpr const std::uint8_t max_queue_retry{
+      30U,
+  };
+
+  const std::uint32_t max_queue_size{
+      std::thread::hardware_concurrency() * 4UL,
+  };
+
+  static constexpr const std::chrono::seconds queue_wait_secs{
+      5s,
+  };
+
 public:
   t_event_system(const t_event_system &) = delete;
   t_event_system(t_event_system &&) = delete;
@@ -102,7 +115,7 @@ private:
     };
 
     if (not get_stop_requested() && event_list_.empty()) {
-      event_notify_.wait_for(lock, 4s);
+      event_notify_.wait_for(lock, queue_wait_secs);
     }
 
     if (not event_list_.empty()) {
@@ -145,27 +158,19 @@ private:
   }
 
   void queue_event(std::shared_ptr<event_type> evt) {
-    static constexpr const auto max_retry{
-        30U,
-    };
-
-    static const auto max_size{
-        std::thread::hardware_concurrency() * 4UL,
-    };
-
     unique_mutex_lock lock(event_mutex_);
     event_list_.push_back(std::move(evt));
     auto size = event_list_.size();
     event_notify_.notify_all();
     lock.unlock();
 
-    for (auto retry{0U};
-         size > max_size && retry < max_retry && not get_stop_requested();
+    for (auto retry{0U}; size > max_queue_size && retry < max_queue_retry &&
+                         not get_stop_requested();
          ++retry) {
       lock.lock();
       size = event_list_.size();
-      if (size > max_size) {
-        event_notify_.wait_for(lock, 1s);
+      if (size > max_queue_size) {
+        event_notify_.wait_for(lock, queue_wait_secs);
         size = event_list_.size();
       }