Merge branch 'master' into fix/mpd-markup-truncation

include/util/json.hpp

@@ -7,6 +7,7 @@
 #include <codecvt>
 #include <iostream>
 #include <locale>
+#include <memory>
 #include <regex>
 
 #if (FMT_VERSION >= 90000)
@@ -26,14 +27,19 @@ class JsonParser {
     Json::Value root;
 
     // replace all occurrences of "\x" with "\u00", because JSON doesn't allow "\x" escape sequences
-    std::string modifiedJsonStr = replaceHexadecimalEscape(jsonStr);
+    std::string modifiedJsonStr;
+    const std::string* json = &jsonStr;
+    if (jsonStr.find("\\x") != std::string::npos) {
+      modifiedJsonStr = replaceHexadecimalEscape(jsonStr);
+      json = &modifiedJsonStr;
+    }
 
-    std::istringstream jsonStream(modifiedJsonStr);
     std::string errs;
     // Use local CharReaderBuilder for thread safety - the IPC singleton's
     // parser can be called concurrently from multiple module threads
     Json::CharReaderBuilder readerBuilder;
-    if (!Json::parseFromStream(readerBuilder, jsonStream, &root, &errs)) {
+    auto reader = std::unique_ptr<Json::CharReader>(readerBuilder.newCharReader());
+    if (!reader->parse(json->data(), json->data() + json->size(), &root, &errs)) {
       throw std::runtime_error("Error parsing JSON: " + errs);
     }
     return root;

include/util/sleeper_thread.hpp

@@ -79,6 +79,12 @@ class SleeperThread {
   auto sleep_for(std::chrono::system_clock::duration dur) {
     std::unique_lock lk(mutex_);
     CancellationGuard cancel_lock;
+
+    condvar_.wait(lk, [this] {
+      return !is_paused_ || signal_.load(std::memory_order_relaxed) ||
+             !do_run_.load(std::memory_order_relaxed);
+    });
+
     constexpr auto max_time_point = std::chrono::steady_clock::time_point::max();
     auto wait_end = max_time_point;
     auto now = std::chrono::steady_clock::now();
@@ -95,6 +101,12 @@ class SleeperThread {
           time_point) {
     std::unique_lock lk(mutex_);
     CancellationGuard cancel_lock;
+
+    condvar_.wait(lk, [this] {
+      return !is_paused_ || signal_.load(std::memory_order_relaxed) ||
+             !do_run_.load(std::memory_order_relaxed);
+    });
+
     return condvar_.wait_until(lk, time_point, [this] {
       return signal_.load(std::memory_order_relaxed) || !do_run_.load(std::memory_order_relaxed);
     });
@@ -122,6 +134,17 @@ class SleeperThread {
     }
   }
 
+  void pause() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    is_paused_ = true;
+  }
+
+  void resume() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    is_paused_ = false;
+    condvar_.notify_all();
+  }
+
   ~SleeperThread() {
     connection_.disconnect();
     stop();
@@ -137,6 +160,7 @@ class SleeperThread {
   std::atomic<bool> do_run_ = true;
   std::atomic<bool> signal_ = false;
   sigc::connection connection_;
+  bool is_paused_{false};
 };
 
 }  // namespace waybar::util