Queue.hpp

Go to the documentation of this file.

#ifndef IV_SRC_CONTAINERS_QUEUE_HPP_
#define IV_SRC_CONTAINERS_QUEUE_HPP_
 
#include <condition_variable>
#include <mutex>
#include <queue>
#include <type_traits>
 
namespace iv::containers
{
 
template<typename T, uint64_t Size>
class Queue
{
public:
    Queue() = default;
    Queue(const Queue &) = delete;
 
    virtual ~Queue()
    {
        clear();
    }
 
    Queue &operator=(const Queue &other) = delete;
 
    void pop(T &item)
    {
        std::scoped_lock lock(m_mutex);
 
        while (m_data.empty())
        {
            m_cond.wait(lock);
        }
 
        item = m_data.front();
        m_data.pop();
    }
 
    bool push(const T &item)
    {
        std::scoped_lock lock(m_mutex);
 
        if (m_data.size() < Size)
        {
            m_data.push(item);
            m_cond.notify_one();
 
            return true;
        }
 
        return false;
    }
 
    void clear()
    {
        std::scoped_lock lock(m_mutex);
 
        while (not m_data.empty())
        {
            if (std::is_pointer<T>::value)
            {
                T item = m_data.front();
                m_data.pop();
 
                delete item;
                item = nullptr;
            }
        }
    }
 
    bool empty()
    {
        std::scoped_lock lock(m_mutex);
        return m_data.empty();
    }
 
    bool full()
    {
        std::scoped_lock lock(m_mutex);
        return m_data.size() == Size;
    }
 
private:
    static_assert(std::is_default_constructible<T>::value, "T must be default constructible");
    static_assert(Size >= 50, "Size is too small!");
    static_assert(Size <= 5000, "Size is too long!");
 
    std::queue<T> m_data;
    std::mutex m_mutex;
    std::condition_variable_any m_cond;
};
 
}// namespace iv::containers
 
#endif//IV_SRC_CONTAINERS_QUEUE_HPP_