lib-during/thread-queue.h

Go to the documentation of this file.

/********************************************************************
 * Copyright (C) 2011 by Verimag                                    *
 * Initial author: Matthieu Moy                                     *
 * This file must not be distributed outside Verimag                *
 ********************************************************************/

#ifndef THREAD_QUEUE_H
#define THREAD_QUEUE_H

#include <boost/thread.hpp>
#include <queue>
#include <iostream>

template<typename T>
class thread_queue {
public:
        void push(const T &t) {
                boost::unique_lock<boost::mutex> lock(m_mut);
                m_queue.push(t);
                m_cond.notify_all();
        };

        void pop() {
                boost::unique_lock<boost::mutex> lock(m_mut);
                while (m_queue.empty()) {
                        m_cond.wait(lock);
                }
                m_queue.pop();
        }

        T pop_front() {
                boost::unique_lock<boost::mutex> lock(m_mut);
                while (m_queue.empty()) {
                        m_cond.wait(lock);
                }
                // This has to be a copy, since pop() would invalidate
                // any pointer/reference.
                T result = m_queue.front();
                m_queue.pop();
                return result;
        }
        
        bool try_pop_front(T &result) {
                boost::unique_lock<boost::mutex> lock(m_mut);
                if (m_queue.empty()) {
                        return false;
                }
                result = m_queue.front();
                m_queue.pop();
                return true;
        }

        T& front() {
                boost::unique_lock<boost::mutex> lock(m_mut);
                while (m_queue.empty()) {
                        m_cond.wait(lock);
                }
                return m_queue.front();
        }

        T& back() {
                boost::unique_lock<boost::mutex> lock(m_mut);
                while (m_queue.empty()) {
                        m_cond.wait(lock);
                }
                return m_queue.back();
        }

        int size() {
                boost::unique_lock<boost::mutex> lock(m_mut);
                return m_queue.size();
        }
        
private:
        std::queue<T> m_queue;

        boost::condition_variable m_cond;
        boost::mutex m_mut;
};

#endif // THREAD_QUEUE_H