mtQueue.h

/* Copyright (c) 2005-2012, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2012, Daniel Nachbaur <danielnachbaur@gmail.com>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * This library 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 Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef LUNCHBOX_MTQUEUE_H
#define LUNCHBOX_MTQUEUE_H

#include <lunchbox/condition.h>
#include <lunchbox/debug.h>

#include <algorithm>
#include <limits.h>
#include <queue>
#include <string.h>

namespace lunchbox
{
    template< typename T, size_t S = ULONG_MAX > class MTQueue
    // S = std::numeric_limits< size_t >::max() does not work:
    //   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=6424
    {
    public:
        class Group;
        typedef T value_type;

        MTQueue( size_t maxSize = S ) : _maxSize( maxSize ) {}

        MTQueue( const MTQueue< T, S >& from )  { *this = from; }

        ~MTQueue() {}

        MTQueue< T, S >& operator = ( const MTQueue< T, S >& from );

        const T& operator[]( const size_t index ) const;

        bool isEmpty() const { return _queue.empty(); }

        size_t getSize() const { return _queue.size(); }

        void setMaxSize( const size_t maxSize );

        size_t getMaxSize() const { return _maxSize; }

        size_t waitSize( const size_t minSize ) const;

        void clear();

        T pop();

        bool timedPop( const unsigned timeout, T& element );

        std::vector< T > timedPopRange( const unsigned timeout,
                                        const size_t minimum = 1,
                                        const size_t maximum = S );

        bool tryPop( T& result );

        void tryPop( const size_t num, std::vector< T >& result );

        bool popBarrier( T& result, Group& barrier );

        bool getFront( T& result ) const;

        bool getBack( T& result ) const;

        void push( const T& element );

        void push( const std::vector< T >& elements );

        void pushFront( const T& element );

        void pushFront( const std::vector< T >& elements );

        void push_back( const T& element ) { push( element ); }
        bool empty() const { return isEmpty(); }

    private:
        std::deque< T > _queue;
        mutable Condition _cond;
        size_t _maxSize;
    };
}

#include "mtQueue.ipp" // template implementation

#endif //LUNCHBOX_MTQUEUE_H