tsqueue.h

/*   
 *   (c) Copyright 2008 Philipp Skadorov (philipp_s@users.sourceforge.net)
 *
 *   This file is part of FREESECS.
 *
 *   FREESECS is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   FREESECS is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with FREESECS, see COPYING.
 *   If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef _TSQUEUE_H
#define _TSQUEUE_H
#include <queue>
#include <pthread.h>
#include <errno.h>

namespace freesecs
{
    class lock_t
    {
    public:
        lock_t(pthread_mutex_t &mutex)
        :_mutex_ref(mutex)
        {
            pthread_mutex_lock(&_mutex_ref);
        }
        ~lock_t()
        {
            pthread_mutex_unlock(&_mutex_ref);
        }
    private:
        lock_t();
        pthread_mutex_t &_mutex_ref;
    };

    template <class T>
    class thread_safe_queue
    {
    private:
        mutable pthread_mutex_t _mutex;
        std::queue<T> _queue;
     
    public:

        typedef typename std::queue<T>::reference reference;
        typedef typename std::queue<T>::const_reference const_reference;
        typedef typename std::queue<T>::value_type value_type;

        thread_safe_queue()
        {
            pthread_mutex_init(&_mutex, NULL);
        }

        ~thread_safe_queue()
        {
            pthread_mutex_destroy(&_mutex);
        }

        bool empty() const
        {
            lock_t l(_mutex);
            return _queue.empty();
        }
        
        size_t size() const
        {
            lock_t l(_mutex);
            return _queue.size();
        }

        reference front()
        {
            lock_t l(_mutex);
            return _queue.front();
        }

        const_reference front() const
        {
            lock_t l(_mutex);
            return _queue.front();
        }

        reference back()
        {
            lock_t l(_mutex);
            return _queue.back();
        }

        const_reference back() const
        {
            lock_t l(_mutex);
            return _queue.back();
        }

        void push(const value_type &x)
        {
            lock_t l(_mutex);
            _queue.push(x);
        }

        void pop()
        {
            lock_t l(_mutex);
            _queue.pop();
        }
    };

}//namespace

#endif //_TSQUEUE_H

---