command_queue.h

#pragma once
 
#include <chrono>
#include <condition_variable>
#include <functional>
#include <mutex>
#include <queue>
#include <utility>
 
namespace pixelbullet::audio_internal
{
class CommandQueue
{
public:
    enum class PopStatus
    {
        Command,
        Timeout,
        Closed,
    };

    bool push(std::function<void()> command)
    {
        if (!command)
        {
            return false;
        }
 
        {
            std::lock_guard<std::mutex> lock(mutex_);
            if (closed_)
            {
                return false;
            }
            queue_.push(std::move(command));
        }
        cond_.notify_one();
        return true;
    }
 
    PopStatus pop_for(std::function<void()>& command, const std::chrono::milliseconds timeout)
    {
        std::unique_lock<std::mutex> lock(mutex_);
        cond_.wait_for(lock, timeout, [this]() { return closed_ || !queue_.empty(); });
 
        if (!queue_.empty())
        {
            command = std::move(queue_.front());
            queue_.pop();
            return PopStatus::Command;
        }
 
        return closed_ ? PopStatus::Closed : PopStatus::Timeout;
    }

    bool pop(std::function<void()>& command)
    {
        std::unique_lock<std::mutex> lock(mutex_);
        cond_.wait(lock, [this]() { return closed_ || !queue_.empty(); });
 
        if (!queue_.empty())
        {
            command = std::move(queue_.front());
            queue_.pop();
            return true;
        }
 
        return false;
    }
 
    void close()
    {
        {
            std::lock_guard<std::mutex> lock(mutex_);
            closed_ = true;
        }
        cond_.notify_all();
    }
 
private:
    std::mutex mutex_;
    std::condition_variable cond_;
    std::queue<std::function<void()>> queue_;
    bool closed_ = false;
};
} // namespace pixelbullet::audio_internal