---

ringbuffer.hh

/*
 * PIAVE - PIAVE Is A Video Editor
 *
 * Copyright (C) 2002 Rolf Dubitzky, rolf@dubitzky.de
 *
 */

/*
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#if ! defined ( RINGBUFFER_HH )
#define RINGBUFFER_HH

namespace PIAVE {

    /*
     * \class RingBuffer implements a simple ringbuffer with pointers
     *
     */
    template< class V >
    class PtrRingBuffer
    {
      public:
        PtrRingBuffer( size_t s = 128 );
        ~PtrRingBuffer();

        void push( const V * v );
        const V * pop();
        int remove( const V * v );
        bool isEmpty() const { return _head==_tail; }
        bool isFull() const { int h=_head; inc(h); return h==_tail; }

      private:
        void inc( int & i ) const { if ( ++i == _size ) i = 0; }

      private:
        const V ** _buffer;
        int _head;
        int _tail;
        int _size;
    };

    template< class V >
    PtrRingBuffer<V>::PtrRingBuffer( size_t s ) :
      _buffer( new const V*[s] ),
      _head( 0 ),
      _tail( 0 ),
      _size( s )
    {
    }

    template< class V >
    PtrRingBuffer<V>::~PtrRingBuffer()
    {
        if ( _buffer ) delete [] _buffer;
    }

    template< class V >
    void
    PtrRingBuffer<V>::push( const V * v )
    {
        if ( isFull() ) {
//            WARN( "Buffer is full - dropping cmnd" );
        } else {
            _buffer[ _head ] = v;
            inc( _head );
        }
        
        return;
    }
    
    template< class V >
    const V *
    PtrRingBuffer<V>::pop()
    {
        /* suppress zores */
        while ( _buffer[ _tail ] == 0 &&
                _tail != _head )
        {
            inc( _tail );
        }

        /* if we have something left, return it */
        if ( isEmpty() ) return 0;

        const V * ret = _buffer[ _tail ];
        _buffer[ _tail ] = 0;

        inc( _tail );

        return ret;
    }

    template< class V >
    int
    PtrRingBuffer<V>::remove( const V * v )
    {
        if ( isEmpty() ) return 0;
        int n = 0;
        for ( int i=_tail; i!=_head; inc(i) )
        {
            if ( _buffer[ i ] != 0 ) {
                if ( *_buffer[ i ] == *v ) {
                    delete _buffer[ i ];
                    _buffer[ i ] = 0;
                    n++;
                }
            }
        }
        return n;
    }    



    /*
     * \class ValRingBuffer implements a simple ringbuffer with values
     * FIXME 
     *     this is just a copy and paste short term solution the
     *     PtrRingBuffer uses dereferencing comparison for remove,
     *     which is not possible for values. Also PtrRB suppresses
     *     zeroes. So putting V* into a ValRB is somethng elsethan
     *     putting V into a PtrRB....  this is ugly and should be
     *     replaced by something better.
     */
    template< class V >
    class ValRingBuffer
    {
      public:
        ValRingBuffer( size_t s = 128 );
        ~ValRingBuffer();

        void push( const V v );
        const V pop();
        bool isEmpty() const { return _head==_tail; }
        bool isFull() const { int h=_head; inc(h); return h==_tail; }

        int getCurSize() const;
        int getN( int n, V * dest );
        int putN( int n, V * src );
        void clean() { _tail = _head; }

      private:
        void inc( int & i ) const { if ( ++i == _size ) i = 0; }

      private:
        V * _buffer;
        int _head;
        int _tail;
        int _size;
    };

    template< class V >
    ValRingBuffer<V>::ValRingBuffer( size_t s ) :
      _buffer( new V[s] ),
      _head( 0 ),
      _tail( 0 ),
      _size( s )
    {
    }

    template< class V >
    ValRingBuffer<V>::~ValRingBuffer()
    {
        if ( _buffer ) delete [] _buffer;
    }

    template< class V >
    void
    ValRingBuffer<V>::push( const V v )
    {
        if ( isFull() ) {
//            WARN( "Buffer is full - dropping cmnd" );
        } else {
            _buffer[ _head ] = v;
            inc( _head );
        }
        
        return;
    }
    
    template< class V >
    const V
    ValRingBuffer<V>::pop()
    {
        /* if we have something left, return it */
        if ( isEmpty() ) return 0;

        const V ret = _buffer[ _tail ];
        _buffer[ _tail ] = 0;

        inc( _tail );

        return ret;
    }

    template< class V >
    int 
    ValRingBuffer<V>::getCurSize() const
    {
        /* wrap */
        if (_tail>_head) return _size-_tail+_head;

        /* no wrap */
        return _head-_tail;
    }
    
    template< class V >
    int 
    ValRingBuffer<V>::getN( int n, V * dest )
    {
        int nCopied = 0;

//        INFO( PRINTV(_head)<<PRINTV(_tail));
        /* empty */
        if (_tail==_head) return 0;

        /* wrap */
        if (_tail>_head) 
        {
            int tail_chunk = _size-_tail;
            if ( n>tail_chunk )
            {
                memcpy( dest, _buffer+_tail, tail_chunk*sizeof(V) );
                nCopied = tail_chunk;
                int rest = 0;
                if ( n-tail_chunk<=_head)
                {
                    rest = n-tail_chunk;
                    _tail = rest;
                } else {
                    rest = _head;
                    _tail = _head;
                }
                memcpy( dest+tail_chunk, _buffer, rest*sizeof(V) );
                nCopied += rest;
            } else {
                memcpy( dest, _buffer+_tail, n*sizeof(V) );
                nCopied = n;
                _tail+=n;
                if ( _tail==_size ) _tail = 0;
            }
//        INFO( PRINTV(_head)<<PRINTV(_tail));
            return nCopied;
        }
        
        /* no wrap */
        int size     = _head-_tail;
        int old_tail = _tail;
        if ( n>size )
        {
            nCopied = size;
            _tail = _head;
        } else {
            nCopied = n;
            _tail+=n;
        }
        memcpy( dest, _buffer+old_tail, nCopied*sizeof(V) );
//        INFO( PRINTV(_head)<<PRINTV(_tail));
        if ( _tail==_size ) _tail = 0;
        return nCopied;
    }

    template< class V >
    int 
    ValRingBuffer<V>::putN( int n, V * src )
    {
        int curSize = getCurSize();
        int free = _size-curSize-1;

        /* full */
        if ( n>free ) return 0;

//        INFO( PRINTV(_head)<<PRINTV(_tail));

        /* wrap */
        int head_chunk = _size-_head;
        if ( n>head_chunk ) 
        {
            memcpy( _buffer+_head, src, head_chunk*sizeof(V) );
            memcpy( _buffer, src+head_chunk, (n-head_chunk)*sizeof(V) );
            _head = n-head_chunk;
            if ( _head==_size ) _head=0;
//            INFO( PRINTV(_head)<<PRINTV(_tail));
            return n;
        }
        
        /* no wrap */
        memcpy( _buffer+_head, src, n*sizeof(V) );
        _head += n;
        if ( _head==_size ) _head=0;
//        INFO( PRINTV(_head)<<PRINTV(_tail));

        return n;
    }

}
    
#endif

---