tsqueue.h

/* Copyright © 2018-2025 Pascal JEAN, All rights reserved.
   This file is part of the Piduino Library.
 
   The Piduino Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.
 
   The Piduino Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public License
   along with the Piduino Library; if not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <condition_variable>
#include <mutex>
#include <queue>
 
// based on https://www.geeksforgeeks.org/dsa/implement-thread-safe-queue-in-c/
 
namespace Piduino {
  template <typename T>
  class TSQueue {
    private:
      std::queue<T> m_queue; //< Underlying queue container.
      mutable std::mutex m_mutex; //< Mutex for synchronizing access.
      std::condition_variable m_cond; //< Condition variable for blocking/waking threads.
 
    public:
      void push (T item) {
 
        // Acquire lock
        std::unique_lock<std::mutex> lock (m_mutex);
 
        // Add item
        m_queue.push (item);
 
        // Notify one thread that
        // is waiting
        m_cond.notify_one();
      }
 
      T pop() {
 
        // acquire lock
        std::unique_lock<std::mutex> lock (m_mutex);
 
        // wait until queue is not empty
        m_cond.wait (lock,
        [this]() {
          return !m_queue.empty();
        });
 
        // retrieve item
        T item = m_queue.front();
        m_queue.pop();
 
        // return item
        return item;
      }
 
      bool empty() const {
 
        // acquire lock
        std::lock_guard<std::mutex> lock (m_mutex);
 
        // return if queue is empty
        return m_queue.empty();
      }
 
      size_t size() const {
 
        // acquire lock
        std::lock_guard<std::mutex> lock (m_mutex);
 
        // return the size of the queue
        return m_queue.size();
      }
 
      void clear() {
 
        // acquire lock
        std::lock_guard<std::mutex> lock (m_mutex);
 
        // clear the queue
        m_queue = std::queue<T>();
      }
  };
}