S3FC project page

S3FC home page

---

               

---

s3_ring_buffer.h

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#ifndef S3_RING_BUFFER_H
#define S3_RING_BUFFER_H

#include <s3fc/s3_exception.h>

template<typename T>
class s3_ring_buffer
{
   /*
    * The buffer can do with more functionality like insert, erase, etc.
    * So if anyone needs methods like that, feel free to add them.
    */
  private:
   unsigned int capacity;

   unsigned int num_of_elems;

   T* buffer;   
   
   unsigned int buffer_start;   
  public:
   s3_ring_buffer(const unsigned int n_capacity)
      : capacity(n_capacity),
   num_of_elems(0),
   buffer(new T[capacity]),
   buffer_start(0)   
   {   
   }   

   s3_ring_buffer(const unsigned int n_capacity, const T& t)
      : capacity(n_capacity),
   num_of_elems(0),
   buffer(new T[capacity]),
   buffer_start(0)   
   {   
      for (unsigned int i = 0; i < capacity; i++)
      {
    push_back(t);     
      }
   } 

   s3_ring_buffer(const s3_ring_buffer& t)
      : capacity(t.get_capacity()),
   num_of_elems(0),
   buffer_start(0)      
   {
      // Setup instance variables and allocate data for the buffer.
      buffer = new T[capacity];
      // Copy data over.
      for (unsigned int i = 0; i < t.size(); i++)
      {
    push_back(t[i]);  
      }            
   }

   ~s3_ring_buffer()
   {
      if (buffer)
      {   
    delete [] buffer;      
      }      
   }   

   void push_back(const T& element)
   {   
      buffer[(buffer_start + size()) % capacity] = element;      

      if ( full() )
      {
    buffer_start = (buffer_start + 1 ) % capacity;
      }
      else 
      {
    num_of_elems++;
      }            
   }   
   unsigned int size() const
   {
      return num_of_elems;      
   }  
   unsigned int get_capacity() const
   {
      return capacity;      
   }   
   bool empty() const   
   {
      return ( size() == 0 );      
   }
   
   bool full() const   
   {
      return ( size() == capacity );      
   }
   
   T& operator[](const unsigned int index) const
   {
      if ( ( size() == 0 ) || 
           ( index < 0 ) ||
           ( index > size()-1 ) )
      {
    throw s3_index_exception("s3_ring_buffer::operator[]"
              "(const unsigned int index) const",
              0, size(), index);
      }
      
      return buffer[ (buffer_start + index) % capacity];      
   }

   T& back( void ) const throw( s3_index_exception )
   {
      if ( empty() )
      {
    throw s3_index_exception("s3_ring_buffer::back() const",
              -1, -1, 0);
      }

      if ( ! full() )
      {
         return buffer[ num_of_elems - 1 ];      
      }
      else
      {
         return buffer[ ( num_of_elems + buffer_start - 1 ) % capacity ];      
      }


   }

   s3_ring_buffer& operator=(const s3_ring_buffer& t)        
   {
      if (buffer)
      {
    delete [] buffer;    
      }
      
      // Setup instance variables and allocate data for the buffer.
      capacity = t.get_capacity();      
      num_of_elems = 0;
      buffer_start = 0;      
      buffer = new T[capacity];
      // Copy data over.
      for (unsigned int i = 0; i < t.size(); i++)
      {
    push_back(t[i]);  
      }       
     
      return *this;      
   }

   bool operator==(const s3_ring_buffer& t)         
   {
      // check capacity
      if ( t.get_capacity() != get_capacity() ) 
      {
    return false;
      }
      // check size
      if ( t.size() != size() ) 
      {
    return false;
      }
      // compare all elements (we start at the first (i.e. oldest) data
      for (unsigned int i=0; i < t.size(); i++)
      {
    if ( t[i] != operator[](i) ) 
         {
       return false;
    }
      }
      return true;
   }
   
};

#endif //S3_RING_BUFFER_H

---

Send comments to: s3fc@stonethree.com