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