BasicQueue.h

#ifndef theplu_yat_utility_basic_queue
#define theplu_yat_utility_basic_queue

// $Id: BasicQueue.h 4043 2021-03-01 04:52:24Z peter $
//
// Copyright (C) 2017, 2018, 2020, 2021 Peter Johansson
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// This program 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
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with yat. If not, see <http://www.gnu.org/licenses/>.

#include "config_public.h"

#include <condition_variable>
#include <limits>
#include <mutex>

namespace theplu {
namespace yat {
namespace utility {
namespace detail {

  template<class Derived, typename T, class Container>
  class BasicQueue
  {
  public:
    typedef typename Container::value_type value_type;

    typedef typename Container::size_type size_type;

    BasicQueue(void)
      : capacity_(std::numeric_limits<size_t>::max())
    {}

    BasicQueue(const BasicQueue& other)
    {
      std::unique_lock<std::mutex> lock(other.mutex_);
      q_ = other.q_;
      capacity_ = other.capacity_;
    } // lock is released here

    explicit BasicQueue(const Container& container)
      : q_(container), capacity_(std::numeric_limits<size_t>::max())
    {}


    size_t capacity(void)
    {
      std::unique_lock<std::mutex> lock(mutex_);
      return capacity_;
    }


    void capacity(size_t c)
    {
      std::unique_lock<std::mutex> lock(mutex_);
      capacity_ = c;

      lock.unlock();
      // Notify pushers that there is potentially space
      push_condition_.notify_all();
    }

    void clear(void)
    {
      std::unique_lock<std::mutex> lock(mutex_);
      q_.clear();
      lock.unlock(); // unlock the mutex

      // Notify pushers that there is space to push
      push_condition_.notify_all();
    }


    bool empty(void) const
    {
      std::unique_lock<std::mutex> lock(mutex_);
      return q_.empty();
    } // lock is released here


    void pop(T& value)
    {
      std::unique_lock<std::mutex> lock(mutex_);
      while (q_.empty())
        pop_condition_.wait(lock);
      // The obvious choice would be to create a temp copy of front,
      // pop the queue and then return by-value. This is, however,
      // dangerous becasue if the copy constructor throws, the queue
      // has been popped and the element is lost. Instead we choose to
      // pass via passed reference.
      static_cast<Derived*>(this)->pop_impl(value, lock);
      lock.unlock(); // unlock the mutex
      push_condition_.notify_one();
    } // lock is released here


    void push(const T& t)
    {
      std::unique_lock<std::mutex> lock(mutex_);
      while (q_.size() >= capacity_)
        push_condition_.wait(lock);
      static_cast<Derived*>(this)->push_impl(t, lock);
      lock.unlock(); // unlock the mutex

      // Notify others that data is ready after we have unlocked
      pop_condition_.notify_one();
    }


    void push(T&& t)
    {
      std::unique_lock<std::mutex> lock(mutex_);
      while (q_.size() >= capacity_)
        push_condition_.wait(lock);
      static_cast<Derived*>(this)->push_impl(std::move(t), lock);
      lock.unlock(); // unlock the mutex

      // Notify others that data is ready after we have unlocked
      pop_condition_.notify_one();
    }


    size_type size(void) const
    {
      std::unique_lock<std::mutex> lock(mutex_);
      return q_.size();
    } // lock is released here


    bool try_pop(T& value)
    {
      std::unique_lock<std::mutex> lock(mutex_);
      if (q_.empty())
        return false;
      static_cast<Derived*>(this)->pop_impl(value, lock);
      lock.unlock(); // unlock the mutex

      // Notify others that data is ready after we have unlocked
      push_condition_.notify_one();
      return true;
    } // lock is released here


    bool try_push(T& value)
    {
      std::unique_lock<std::mutex> lock(mutex_);
      if (q_.size() >= capacity_)
        return false;
      static_cast<Derived*>(this)->push_impl(value, lock);
      lock.unlock(); // unlock the mutex

      // Notify others that data is ready after we have unlocked
      pop_condition_.notify_one();
      return true;
    } // lock is released here


    bool try_push(T&& value)
    {
      std::unique_lock<std::mutex> lock(mutex_);
      if (q_.size() >= capacity_)
        return false;
      static_cast<Derived*>(this)->push_impl(std::move(value), lock);
      lock.unlock(); // unlock the mutex

      // Notify others that data is ready after we have unlocked
      pop_condition_.notify_one();
      return true;
    } // lock is released here

  protected:
    void assign(const BasicQueue& other)
    {
      if (this != &other) {
        // std::lock guarantees that the two mutexes are locked in
        // the same order regardless of passed order and thereby
        // avoiding deadlock when two threads are calling
        // lhs.assign(rhs) and rhs.assign(lhs) simultaneously.
        std::lock(mutex_, other.mutex_);
        std::unique_lock<std::mutex> lock(mutex_, std::adopt_lock_t());
        std::unique_lock<std::mutex> other_lock(other.mutex_,
                                                std::adopt_lock_t());
        q_ = other.q_;
        capacity_ = other.capacity_;
      }
    }

    Container q_;
  private:
    mutable std::mutex mutex_;
    std::condition_variable pop_condition_;
    std::condition_variable push_condition_;
    size_t capacity_;
  };

}}}}
#endif