Concurrent Queue.h

#pragma once
#include<queue>
#include<condition_variable>
#include<mutex>
#include<functional>

namespace concurrent {

    typedef std::function<bool(void)> c_queue_predicate;

    template<typename T>
    class queue {
    private:
        std::queue<T> _queue;
        mutable std::mutex _mutex;
        mutable std::condition_variable _cond;
    public:
        void push(const T & t) {
            std::unique_lock<std::mutex> lock(_mutex);
            _queue.push(t);
            lock.unlock();
            _cond.notify_one();
        }

        bool empty() const {
            std::unique_lock<std::mutex> lock(_mutex);
            return _queue.empty();
        }

        bool try_pop(T & value) {
            std::unique_lock<std::mutex> lock(_mutex);
            if (_queue.empty()) {
                return false;
            }

            value = _queue.front();
            _queue.pop();
            return true;
        }

        void wait_and_pop(T & value) {
            std::unique_lock<std::mutex> lock(_mutex);
            _cond.wait(lock, [&]() {return !_queue.empty(); });

            value = _queue.front();
            _queue.pop();
        }

        bool wait_and_pop(T & value, c_queue_predicate & test) {
            std::unique_lock<std::mutex> lock(_mutex);
            while (_queue.empty() && !test())
                _cond.wait(lock, test);

            if (test()) return false;
            value = _queue.front();
            _queue.pop();
            return true;
        }

        size_t size() const {
            std::unique_lock<std::mutex> lock(_mutex);
            return _queue.size();
        }

        void wake_all() {
            _cond.notify_all();
        }
    };
}