clang format

include/spdlog/details/mpmc_blocking_q.h

@@ -19,19 +19,16 @@
 namespace spdlog {
 namespace details {
 
-template<typename T>
-class mpmc_blocking_queue
-{
+template <typename T>
+class mpmc_blocking_queue {
 public:
     using item_type = T;
     explicit mpmc_blocking_queue(size_t max_items)
-        : q_(max_items)
-    {}
+        : q_(max_items) {}
 
 #ifndef __MINGW32__
     // try to enqueue and block if no room left
-    void enqueue(T &&item)
-    {
+    void enqueue(T &&item) {
         {
             std::unique_lock<std::mutex> lock(queue_mutex_);
             pop_cv_.wait(lock, [this] { return !this->q_.full(); });
@@ -41,8 +38,7 @@ public:
     }
 
     // enqueue immediately. overrun oldest message in the queue if no room left.
-    void enqueue_nowait(T &&item)
-    {
+    void enqueue_nowait(T &&item) {
         {
             std::unique_lock<std::mutex> lock(queue_mutex_);
             q_.push_back(std::move(item));
@@ -50,36 +46,29 @@ public:
         push_cv_.notify_one();
     }
 
-    void enqueue_if_have_room(T &&item)
-    {
+    void enqueue_if_have_room(T &&item) {
         bool pushed = false;
         {
             std::unique_lock<std::mutex> lock(queue_mutex_);
-            if (!q_.full())
-            {
+            if (!q_.full()) {
                 q_.push_back(std::move(item));
                 pushed = true;
             }
         }
 
-        if (pushed)
-        {
+        if (pushed) {
             push_cv_.notify_one();
-        }
-        else
-        {
+        } else {
             ++discard_counter_;
         }
     }
 
     // dequeue with a timeout.
     // Return true, if succeeded dequeue item, false otherwise
-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
-    {
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
         {
             std::unique_lock<std::mutex> lock(queue_mutex_);
-            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
-            {
+            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {
                 return false;
             }
             popped_item = std::move(q_.front());
@@ -90,8 +79,7 @@ public:
     }
 
     // blocking dequeue without a timeout.
-    void dequeue(T &popped_item)
-    {
+    void dequeue(T &popped_item) {
         {
             std::unique_lock<std::mutex> lock(queue_mutex_);
             push_cv_.wait(lock, [this] { return !this->q_.empty(); });
@@ -106,8 +94,7 @@ public:
     // so release the mutex at the very end each function.
 
     // try to enqueue and block if no room left
-    void enqueue(T &&item)
-    {
+    void enqueue(T &&item) {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         pop_cv_.wait(lock, [this] { return !this->q_.full(); });
         q_.push_back(std::move(item));
@@ -115,40 +102,32 @@ public:
     }
 
     // enqueue immediately. overrun oldest message in the queue if no room left.
-    void enqueue_nowait(T &&item)
-    {
+    void enqueue_nowait(T &&item) {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         q_.push_back(std::move(item));
         push_cv_.notify_one();
     }
 
-    void enqueue_if_have_room(T &&item)
-    {
+    void enqueue_if_have_room(T &&item) {
         bool pushed = false;
         std::unique_lock<std::mutex> lock(queue_mutex_);
-        if (!q_.full())
-        {
+        if (!q_.full()) {
             q_.push_back(std::move(item));
             pushed = true;
         }
 
-        if (pushed)
-        {
+        if (pushed) {
             push_cv_.notify_one();
-        }
-        else
-        {
+        } else {
             ++discard_counter_;
         }
     }
 
     // dequeue with a timeout.
     // Return true, if succeeded dequeue item, false otherwise
-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
-    {
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration) {
         std::unique_lock<std::mutex> lock(queue_mutex_);
-        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
-        {
+        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); })) {
             return false;
         }
         popped_item = std::move(q_.front());
@@ -158,8 +137,7 @@ public:
     }
 
     // blocking dequeue without a timeout.
-    void dequeue(T &popped_item)
-    {
+    void dequeue(T &popped_item) {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         push_cv_.wait(lock, [this] { return !this->q_.empty(); });
         popped_item = std::move(q_.front());
@@ -169,33 +147,24 @@ public:
 
 #endif
 
-    size_t overrun_counter()
-    {
+    size_t overrun_counter() {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         return q_.overrun_counter();
     }
 
-    size_t discard_counter()
-    {
-        return discard_counter_.load(std::memory_order_relaxed);
-    }
+    size_t discard_counter() { return discard_counter_.load(std::memory_order_relaxed); }
 
-    size_t size()
-    {
+    size_t size() {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         return q_.size();
     }
 
-    void reset_overrun_counter()
-    {
+    void reset_overrun_counter() {
         std::unique_lock<std::mutex> lock(queue_mutex_);
         q_.reset_overrun_counter();
     }
 
-    void reset_discard_counter()
-    {
-        discard_counter_.store(0, std::memory_order_relaxed);
-    }
+    void reset_discard_counter() { discard_counter_.store(0, std::memory_order_relaxed); }
 
 private:
     std::mutex queue_mutex_;