blocking_queue.h

#pragma once
#include <condition_variable>
#include <deque>
#include <mutex>
#include "../api_status.h"
 
namespace cl::threading {
    template <typename T>
    class blocking_queue {
    private:
        bool closed {false};
        std::condition_variable cond;
        std::deque<T> q;
        std::mutex mtx;
 
    public:
        void push(T&& item) {
            // Add the item to the queue under a mutex lock
            {
                std::lock_guard<std::mutex> lock{ mtx };
                q.push_front(std::move(item));
            }
 
            cond.notify_one();
        }
 
        cl::api_status pop(T* next) {
            // Grab the lock and wait for the condvar to receive a notification
            std::unique_lock<std::mutex> lock{ mtx };
            this->cond.wait(lock, [this](){
                return closed || !this->q.empty();
            });
 
            // If the queue has been closed, stop pulling values
            if (closed) {
                return api_status::no_result;
            }
 
            // Once we get the signal, pop an item from the queue
            *next = std::move(q.back());
            q.pop_back();
            return api_status::ok;
        }
 
        size_t workload_count() const {
            return q.size();
        }
 
        void close() {
            // Set the closed flag and wake up the thread
            {
                std::lock_guard<std::mutex> lock{ mtx };
                closed = true;
            }
 
            // Unblock the thread
            cond.notify_one();
        }
    };
}