queue.h

Go to the documentation of this file.

 
#pragma once
 
#include <queue>
#include <promeki/core/namespace.h>
#include <promeki/core/error.h>
#include <promeki/core/list.h>
#include <promeki/core/mutex.h>
#include <promeki/core/waitcondition.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T>
class Queue {
        public:
                Queue() { };
                ~Queue() { };
 
                void push(const T &val) {
                        Mutex::Locker locker(_mutex);
                        _queue.push(val);
                        _cv.wakeOne();
                        return;
                }
 
                void push(T &&val) {
                        Mutex::Locker locker(_mutex);
                        _queue.push(std::move(val));
                        _cv.wakeOne();
                        return;
                }
 
                template <typename... Args>
                void emplace(Args&&... args) {
                        Mutex::Locker locker(_mutex);
                        _queue.emplace(std::forward<Args>(args)...);
                        _cv.wakeOne();
                        return;
                }
 
                void push(const List<T> &list) {
                        Mutex::Locker locker(_mutex);
                        for(const auto &item : list) _queue.push(item);
                        _cv.wakeAll();
                        return;
                }
 
                std::pair<T, Error> pop(unsigned int timeoutMs = 0) {
                        Mutex::Locker locker(_mutex);
                        Error err = _cv.wait(_mutex,
                                [this] { return !_queue.empty(); }, timeoutMs);
                        if(err != Error::Ok) return {T{}, err};
                        T ret = std::move(_queue.front());
                        _queue.pop();
                        if(_queue.empty()) _cv.wakeAll();
                        return {std::move(ret), Error::Ok};
                }
 
                bool popOrFail(T &val) {
                        Mutex::Locker locker(_mutex);
                        if(_queue.empty()) return false;
                        val = std::move(_queue.front());
                        _queue.pop();
                        if(_queue.empty()) _cv.wakeAll();
                        return true;
                }
 
                std::pair<T, Error> peek(unsigned int timeoutMs = 0) {
                        Mutex::Locker locker(_mutex);
                        Error err = _cv.wait(_mutex,
                                [this] { return !_queue.empty(); }, timeoutMs);
                        if(err != Error::Ok) return {T{}, err};
                        T ret = _queue.front();
                        return {std::move(ret), Error::Ok};
                }
 
                bool peekOrFail(T &val) {
                        Mutex::Locker locker(_mutex);
                        if(_queue.empty()) return false;
                        val = _queue.front();
                        return true;
                }
 
                Error waitForEmpty(unsigned int timeoutMs = 0) {
                        Mutex::Locker locker(_mutex);
                        return _cv.wait(_mutex,
                                [this] { return _queue.empty(); }, timeoutMs);
                }
 
                bool isEmpty() const {
                        Mutex::Locker locker(_mutex);
                        return _queue.empty();
                }
 
                size_t size() const {
                        Mutex::Locker locker(_mutex);
                        return _queue.size();
                }
 
                void clear() {
                        Mutex::Locker locker(_mutex);
                        std::queue<T> empty;
                        std::swap(_queue, empty);
                        return;
                }
 
        private:
                mutable Mutex           _mutex;
                WaitCondition           _cv;
                std::queue<T>           _queue;
};
 
PROMEKI_NAMESPACE_END