wefts_ringbuffer.h

Go to the documentation of this file.

/*
   wefts_ringbuffer.h
   Ringbuffer sync object

   $Id: wefts_ringbuffer.h,v 1.4 2004/03/28 21:45:40 jonnymind Exp $
---------------------------------------------
   Begin      : 2003-08-16 21:25
   Author     : Giancarlo Niccolai

   Last modified because:

*/

/**************************************************************************
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU Library General Public License as       *
*   published by the Free Software Foundation; either version 2.1 of the  *
*   License, or (at your option) any later version.                       *
***************************************************************************/

#ifndef WT_RINGBUFFER_H
#define WT_RINGBUFFER_H

#include <wefts_mutex.h>
#include <wefts_cond.h>
#include <wefts_cleanup.h>
#include <iostream>

namespace Wefts {

template < typename _T >
class RingBuffer: public CleanupHandler
{
private:
   Mutex m_mutex;
   Condition m_rCond;
   Condition m_wCond;

   _T *m_buffer;

   unsigned long m_size;

   unsigned long m_wPos;
   unsigned long m_rPos;

   int m_wWaiting;
   int m_rWaiting;

   bool empty() const {
      return ( m_wPos == m_rPos + 1||
         (m_size > 1 &&m_wPos == 0 && m_rPos == m_size-1) );
   }

   bool full() const {
      return (m_wPos == m_rPos);
   }

   void put( _T data ) {

      bool was_empty = empty();
      if ( m_size == 1 ) {
         *m_buffer = data;
         m_wPos = 0;
      }
      else {
         m_buffer[ m_wPos ++ ] = data;
         if ( m_wPos == m_size ) m_wPos = 0;
      }

      if( was_empty && m_rWaiting != 0 )
         m_rCond.signal(); // tell the readers situation has changed.
   }


   _T get() {
      bool was_full = full();

      if ( m_rPos == m_size -1)
         m_rPos = 0;
      else
         m_rPos++;

      if( was_full && m_wWaiting != 0 ) {
         m_wCond.signal();
      }
      if ( m_size == 1 ) m_wPos = 1;

      return m_buffer[ m_rPos ];
   }


public:

   RingBuffer ( const unsigned long size ) throw( InitError )
   {
      if ( size == 0 ) throw InitError();
      m_buffer = new _T[ size ];
      if ( m_buffer == 0 ) throw InitError();

      m_size = size;

      m_wPos = 1;
      m_rPos = 0;
      m_wWaiting = 0;
      m_rWaiting = 0;

      m_wCond.setMutex( &m_mutex );
      m_rCond.setMutex( &m_mutex );
   }

   ~RingBuffer() { delete m_buffer; }

   unsigned long size() const { m_size; }

   unsigned long free() {
      unsigned long ret;

      m_mutex.lock();
      if ( m_wPos > m_rPos )
         m_ret = m_size -m_wPos + m_rPos + 1;
      else
         m_ret = m_rPos - m_wPos;
      m_mutex.unlock();

      return ret;
   }

   void write( _T data )
   {
      m_mutex.lock();

      // have we to wait?
      if( full() ) {
         m_wWaiting++;
         while ( full() ) {
            // position == 0 --> cleanup a writer
            m_wCond.wait( this, 0 );
         }
         m_wWaiting--;
      }
      put( data );

      m_mutex.unlock();
   }

   /* Waits until some data may be read and returns the read data. 
   \return The element that has been read from the buffer.
   */
   _T read()
   {
      m_mutex.lock();

      // have we to wait?
      if( empty() ) {
         m_rWaiting++;
         while ( empty() ) {
            // position == 1 --> cleanup a reader
            m_rCond.wait( this, 1 );
         }
         m_rWaiting--;
      }
      _T data = get();
      m_mutex.unlock();
      return data;
   }


   bool tryWrite( _T data ) {
      bool ret;

      m_mutex.lock();
      if ( ! full() ) {
         put( data );
         ret = true;
      }
      else
         ret = false;
      m_mutex.unlock();

      return ret;
   }

   bool tryRead( _T &data ) {
      bool ret;

      m_mutex.lock();
      if ( ! empty() ) {
         data = get();
         ret = true;
      }
      else
         ret = false;
      m_mutex.unlock();

      return ret;
   }

   virtual void handleCleanup( int pos, void * )
   {
      if ( pos == 0 ) 
         // cleanup a writer
         m_wWaiting--;
      else
         // cleanup a reader
         m_rWaiting--;

      m_mutex.unlock();
   }
};

}
#endif

/* end wefts_ringbuffer.h */

---