shared_queue.h

Go to the documentation of this file.

 
#ifndef SHAREDQUEUE_H
#define SHAREDQUEUE_H
 
#include <atomic>
#include <mutex>
#include <queue>
 
template <typename T>
class shared_queue {
public:
    shared_queue() : queue_empty_(true){};
    ~shared_queue(){};
 
    shared_queue(const shared_queue& other) {
        std::lock_guard<std::mutex> other_lock(other.queue_mutex_);
        std::lock_guard<std::mutex> this_lock(queue_mutex_);
 
        // Copy is not atomic
        bool qe = other.queue_empty_;
        queue_empty_ = qe;
 
        internal_queue_ = other.internal_queue_;
    };
 
    shared_queue& operator=(const shared_queue& other) {
        std::lock_guard<std::mutex> other_lock(other.queue_mutex_);
        std::lock_guard<std::mutex> this_lock(queue_mutex_);
 
        // Copy is not atomic
        bool qe = other.queue_empty_;
        queue_empty_ = qe;
 
        internal_queue_ = other.internal_queue_;
 
        return *this;
    };
 
    void push(const T& value) {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        internal_queue_.push(value);
 
        queue_empty_ = internal_queue_.empty();
    };
 
    void push(const std::vector<T>& values) {
        std::lock_guard<std::mutex> lock(queue_mutex_);
 
        for (typename std::vector<T>::const_iterator it = values.begin();
             it != values.end(); ++it) {
            internal_queue_.push(*it);
            queue_empty_ = internal_queue_.empty();
        }
    };
 
    T& front() {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        return internal_queue_.front();
    };
 
    const T& front() const {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        return internal_queue_.front();
    };
 
    T front_pop() {
        std::lock_guard<std::mutex> lock(queue_mutex_);
 
        T value = internal_queue_.front();
        internal_queue_.pop();
        queue_empty_ = internal_queue_.empty();
 
        return value;
    };
 
    void pop() {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        internal_queue_.pop();
 
        queue_empty_ = internal_queue_.empty();
    };
 
    bool empty() const {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        return internal_queue_.empty();
    }
 
    bool fast_empty() const { return queue_empty_; }
 
    size_t size() const {
        std::lock_guard<std::mutex> lock(queue_mutex_);
        return internal_queue_.size();
    }
 
private:
    mutable std::mutex queue_mutex_;
    std::atomic<bool> queue_empty_;
    std::queue<T> internal_queue_;
};
 
#endif