threadsafe_queue.h

#pragma once
#include <deque>
#include <mutex>
#include <optional>
#include <queue>
#include <utility>
 
namespace asyncpp {
    template<typename T, typename Container = std::deque<T>>
    class threadsafe_queue {
        std::mutex m_mutex{};
        std::queue<T, Container> m_queue{};
 
    public:
        template<typename... Args>
        explicit threadsafe_queue(Args&&... args) : m_queue(std::forward<Args>(args)...) {}
 
        threadsafe_queue(const threadsafe_queue& other) {
            std::scoped_lock lck{other.m_mutex};
            m_queue = other.m_queue;
        }
        //NOLINTNEXTLINE(performance-noexcept-move-constructor)
        threadsafe_queue(threadsafe_queue&& other) {
            std::scoped_lock lck{other.m_mutex};
            m_queue = std::move(other.m_queue);
        }
        threadsafe_queue& operator=(const threadsafe_queue& other) {
            if (&other != this) {
                std::scoped_lock lck{other.m_mutex, m_mutex};
                m_queue = other.m_queue;
            }
            return *this;
        }
        //NOLINTNEXTLINE(performance-noexcept-move-constructor)
        threadsafe_queue& operator=(threadsafe_queue&& other) {
            if (&other != this) {
                std::scoped_lock lck{other.m_mutex, m_mutex};
                m_queue = std::move(other.m_queue);
            }
            return *this;
        }
 
        std::optional<T> pop() {
            std::scoped_lock lck{m_mutex};
            if (m_queue.empty()) return std::nullopt;
            auto entry = std::move(m_queue.front());
            m_queue.pop();
            return entry;
        }
 
        void push(T val) {
            std::scoped_lock lck{m_mutex};
            m_queue.push(std::move(val));
        }
 
        template<typename... Args>
        void emplace(Args&&... args) {
            std::scoped_lock lck{m_mutex};
            m_queue.emplace(std::forward<Args>(args)...);
        }
    };
} // namespace asyncpp