RingBuffer.h

#ifndef UTIL_RING_BUFFER_H
#define UTIL_RING_BUFFER_H

/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include <util/misc/Memory.h>
#include <util/global.h>

namespace Util
{

   template <class Data>
   class RingBuffer
   {
   
   public: 
   
      RingBuffer();
   
      RingBuffer(const RingBuffer<Data>& other);
   
      RingBuffer& operator = (const RingBuffer<Data>& other);
   
      virtual ~RingBuffer();
   
      void allocate(int capacity);

      void clear();
  
      void append(Data value);
   
      int size() const;
  
      int capacity() const;
  
      bool isAllocated() const;
   
      bool isFull() const;
   
      const Data& operator [] (int offset) const;

      Data& operator [] (int offset);

      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);

   private:
  
      Data* data_;     

      int   capacity_; 

      int   size_;     

      int   last_;     
  
   };

   /*
   * Default contructor
   */
   template <class Data>
   RingBuffer<Data>::RingBuffer()
    : data_(0),
      capacity_(0),
      size_(0),
      last_(0)
   {}

   /*
   * Copy constructor.
   *
   * Allocates new memory and copies all elements by value.
   *
   *\param other the RingBuffer to be copied.
   */
   template <class Data>
   RingBuffer<Data>::RingBuffer(const RingBuffer<Data>& other) 
    : data_(0),
      capacity_(0),
      size_(0),
      last_(0)
   {
      if (other.capacity_ > 0) {
         assert(other.data_ != 0);
         Memory::allocate<Data>(data_, other.capacity_);
         capacity_ = other.capacity_;
         size_ = other.size_;
         last_ = other.last_;
         for (int i = 0; i < capacity_; ++i) {
            data_[i] = other.data_[i];
         }
      }
   }

   /*
   * Assignment, element-by-element.
   *
   * Assignment is allowed only for allocated RingBuffer objects of equal 
   * capacity.  This operator will allocate this RingBuffer if it was not 
   * allocated previously.
   */
   template <class Data>
   RingBuffer<Data>& 
   RingBuffer<Data>::operator = (const RingBuffer<Data>& other) 
   {

      // Check for self assignment
      if (this == &other) return *this;

      if (other.isAllocated()) {

         assert(other.capacity_ > 0);

         if (!isAllocated()) {

            Memory::allocate<Data>(data_, other.capacity_);
            capacity_ = other.capacity_;

         } else if (capacity_ != other.capacity_) {

            UTIL_THROW("Cannot assign RingBuffers of unequal capacity");

         }

         size_ = other.size_;
         last_ = other.last_;

         for (int i = 0; i < capacity_; ++i) {
            data_[i] = other.data_[i];
         }

      } else if (isAllocated()) {
         UTIL_THROW("Cannot assign unallocated array to allocated array");
      }

      return *this;
   }

   template <class Data>
   RingBuffer<Data>::~RingBuffer()
   {
      if (data_) {
         Memory::deallocate<Data>(data_, capacity_);
      }
   }

   template <class Data>
   void  RingBuffer<Data>::allocate(int capacity) 
   {
      if (data_ == 0) {
         Memory::allocate<Data>(data_, capacity);
         capacity_ = capacity;
      } else {
         UTIL_THROW("Error: Attempt to re-allocate a RingBuffer");
      }
      last_ = capacity_ - 1; 
      size_ = 0;        // No values in buffer
   }

   /*
   * Set buffer to empty state, by resetting counters.
   */
   template <class Data>
   inline
   void RingBuffer<Data>::clear()
   {
      last_  = capacity_ - 1; 
      size_  = 0;        
   }
 
   /* 
   * Append a new value to the end of the buffer
   */
   template <class Data>
   inline
   void RingBuffer<Data>::append(Data data) 
   {
      assert(last_ < capacity_);
      ++last_;
      if (last_ == capacity_) {
         last_ = 0; // wrap around
      };
      data_[last_] = data;
   
      // If buffer is not yet full, update size_
      if (size_ < capacity_) {
         ++size_;
      };

   }
   
   /*
   * Return number of values in buffer.
   */
   template <class Data>
   inline
   int RingBuffer<Data>::size() const
   { return size_; }
  
   /*
   * Return the capacity of the buffer.
   */
   template <class Data>
   inline
   int RingBuffer<Data>::capacity() const
   { return capacity_; }
 
   /* 
   * Return true if the RingBuffer has been allocated, false otherwise.
   */
   template <class Data>
   inline
   bool RingBuffer<Data>::isAllocated() const
   {  return (data_ != 0); }
  
   /* 
   * Return true if the RingBuffer is full.
   */
   template <class Data>
   inline
   bool RingBuffer<Data>::isFull() const
   {  return (size_ == capacity_); }
  
   /*
   * Retrive a value by const reference, index backwards from 0 (current)
   */
   template <class Data>
   inline
   const Data& RingBuffer<Data>::operator [] (int offset) const
   {
      if ( offset >= size_ )  {
         UTIL_THROW("offset >= size_");
      }
      int i;
      i = last_ - offset;
      if (i < 0) {
         i = i + capacity_;
      }
      return data_[i];
   }

   /*
   * Retrive a value by reference, index backwards from 0 (current)
   */
   template <class Data>
   inline
   Data& RingBuffer<Data>::operator [] (int offset)
   {
      if ( offset >= size_ )  {
         UTIL_THROW("offset >= size_");
      }
      int i;
      i = last_ - offset;
      if (i < 0) {
         i = i + capacity_;
      }
      return data_[i];
   }

   /*
   * Serialize a RingBuffer to/from an Archive.
   */
   template <class Data>
   template <class Archive>
   void RingBuffer<Data>::serialize(Archive& ar, const unsigned int version)
   {
      int capacity;
      if (Archive::is_saving()) {
         capacity = capacity_;
      }
      ar & capacity;
      if (Archive::is_loading()) {
         if (!isAllocated()) {
            if (capacity > 0) {
               allocate(capacity);
            } else {
               capacity_ = 0;
            }
         } else {
            if (capacity != capacity_) {
               UTIL_THROW("Inconsistent RingBuffer capacities");
            }
         }
      }
      ar & size_;
      ar & last_;
      for (int i = 0; i < capacity_; ++i) {
         ar & data_[i];
      }
   }

}
#endif