SynchronizedQueue.hpp

#ifndef _LIBRARY_DATASTRUCTURES_SYNCHRONIZEDQUEUE_HPP
#define _LIBRARY_DATASTRUCTURES_SYNCHRONIZEDQUEUE_HPP

#include <concepts>
#include <condition_variable>
#include <cstddef>
#include <deque>
#include <mutex>
#include <optional>
#include <utility>

namespace DataStructures
{

    template<typename Data>
        requires(std::copyable<Data> || std::movable<Data>)
    class SynchronizedQueue
    {
        std::deque<Data> data;
        mutable std::mutex lock;
        std::condition_variable conditional;

        auto pop_and_return()
        {
            auto retval = std::move(data.front());
            data.pop_front();
            return retval;
        }

    public:
        std::optional<Data> try_pop()
        {
            std::lock_guard<std::mutex> guard(lock);
            if (data.empty())
                return {};

            return pop_and_return();
        }

        Data wait_and_pop()
        {
            std::unique_lock<std::mutex> guard(lock);
            conditional.wait(guard, [this]() { return !data.empty(); });

            return pop_and_return();
        }

        void push(Data val)
        {
            std::lock_guard<std::mutex> guard(lock);
            data.emplace_back(std::move(val));
            conditional.notify_one();
        }

        size_t was_size() const
        {
            std::lock_guard<std::mutex> guard(lock);
            return data.size();
        }

        bool was_empty() const
        {
            std::lock_guard<std::mutex> guard(lock);
            return data.empty();
        }
    };

}  // namespace DataStructures

#endif  // !_LIBRARY_DATASTRUCTURES_SYNCHRONIZEDQUEUE_HPP