SyncQueues.h

#pragma once

template<class T>
class SynchronizedQueue {

private:
    SynchronizedQueue(SynchronizedQueue<T>&);

    SynchronizedQueue<T> operator=(SynchronizedQueue<T>&);

protected:
    std::deque<T> queue;

    mutable std::mutex mut;

    std::condition_variable not_empty;

public:
    SynchronizedQueue() {
    }

    size_t Size() const {
        std::lock_guard<std::mutex> lock(mut);
        return queue.size();
    }

    void Clear() {
        std::lock_guard<std::mutex> lock(mut);
        queue.clear();
    }

    void Enqueue(const T& elem) {
        {
        std::lock_guard<std::mutex> lock(mut);
        queue.push_back(elem);
        }
        not_empty.notify_one();
    }

    void Enqueue(T&& elem) {
        {
        std::lock_guard<std::mutex> lock(mut);
        queue.push_back(elem);
        }
        not_empty.notify_one();
    }

    T Dequeue() {
        std::unique_lock<std::mutex> lock(mut);
        while ( queue.empty() )
            not_empty.wait(lock);
        T tmp(queue.front());
        queue.pop_front();
        return tmp;
    }

    T Dequeue(const std::chrono::milliseconds& timeout) {
        std::unique_lock<std::mutex> lock(mut);
        while ( queue.empty() )
            not_empty.wait_for(lock, timeout);
        T tmp(queue.front());
        queue.pop_front();
        return tmp;
    }
};