lfQueue.h

/* Copyright (c) 2010, Stefan Eilemann <eile@equalizergraphics.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 COBASE_LFQUEUE_H
#define COBASE_LFQUEUE_H

#include <co/base/atomic.h> // member
#include <co/base/debug.h>  // used in inline method
#include <co/base/nonCopyable.h>  // base class
#include <co/base/thread.h> // thread-safety checks

#include <vector>

namespace co
{
namespace base
{
    template< typename T > class LFQueue : public NonCopyable
    {
    public:
        LFQueue( const int32_t size )
                : _data( size + 1 ), _readPos( 0 ), _writePos( 0 ) {}

        ~LFQueue() {}

        bool isEmpty() const { return _readPos == _writePos; }

        void clear()
            {
                EQ_TS_SCOPED( _reader );
                _readPos = 0;
                _writePos = 0;
            }
            
        void resize( const int32_t size )
            {
                EQASSERT( isEmpty( ));
                _readPos = 0;
                _writePos = 0;
                _data.resize( size + 1 );
            }

        bool pop( T& result )
            {
                EQ_TS_SCOPED( _reader );
                if( _readPos == _writePos )
                    return false;
                
                result = _data[ _readPos ];
                _readPos = (_readPos + 1) % _data.size();
                return true;
            }

        bool getFront( T& result )
            {
                EQ_TS_SCOPED( _reader );
                if( _readPos == _writePos )
                    return false;
                
                result = _data[ _readPos ];
                return true;
            }

        bool push( const T& element )
            {
                EQ_TS_SCOPED( _writer );
                int32_t nextPos = (_writePos + 1) % _data.size();
                if( nextPos == _readPos )
                    return false;

                _data[ _writePos ] = element;
                _writePos = nextPos;
                return true;
            }

        size_t getCapacity() const { return _data.size() - 1; }

    private:
        std::vector< T > _data;
        a_int32_t _readPos;
        a_int32_t _writePos;

        EQ_TS_VAR( _reader );
        EQ_TS_VAR( _writer );
    };

}
}
#endif // COBASE_LFQUEUE_H