spk_thread_safe_queue.hpp

#pragma once
 
#include <deque>
#include <mutex>
 
namespace spk
{
    template <typename TType>
    class ThreadSafeQueue
    {
    public:
        using value_type = TType;
 
    private:
        mutable std::mutex _mutex;
        std::deque<TType> _queue;
 
    public:
        void insert(TType &&p_value)
        {
            std::lock_guard<std::mutex> lock(_mutex);
            _queue.push_back(std::move(p_value));
        }

        void insert(const TType &p_value)
        {
            std::lock_guard<std::mutex> lock(_mutex);
            _queue.push_back(p_value);
        }

        TType popFront()
        {
            std::lock_guard<std::mutex> lock(_mutex);
            if (_queue.empty() == true)
            {
                throw std::runtime_error("Can't popFront an empty ThreadSafeQueue");
            }
            TType out = std::move(_queue.front());
            _queue.pop_front();
            return out;
        }

        TType popBack()
        {
            std::lock_guard<std::mutex> lock(_mutex);
            if (_queue.empty() == true)
            {
                throw std::runtime_error("Can't popBack an empty ThreadSafeQueue");
            }
            TType out = std::move(_queue.back());
            _queue.pop_back();
            return out;
        }

        bool empty() const noexcept
        {
            std::lock_guard<std::mutex> lock(_mutex);
            return _queue.empty();
        }
    };
}