static_circular_buffer.h

Go to the documentation of this file.

 
#ifndef STATICCIRCULARBUFFER_H
#define STATICCIRCULARBUFFER_H
 
#include <memory>
#include <vector>
template <typename T, typename Allocator = std::allocator<T>>
class StaticCircularBuffer
{
public:
 typedef std::vector<T, Allocator> VectorType;
 
  StaticCircularBuffer(size_t max_size, const T& val, const Allocator& alloc = Allocator())
    : buffer_(alloc)
  {
    set_capacity(max_size, val);
  }
 
  StaticCircularBuffer()
  {
   begin_iterator_ = buffer_.begin();
   end_iterator_ = begin_iterator_;
  }
 
  void clear()
  {
    begin_iterator_ = buffer_.begin();
    end_iterator_ = begin_iterator_;
    full_ = false;
  }
 
  void set_capacity(size_t max_size, const T& val)
  {
    buffer_.assign(max_size, val);
    clear();
  }
 
 
  size_t capacity() const
  {
    return buffer_.size();
  }
 
  size_t size() const
  {
    if (full_)
      return capacity();
    else if (begin_iterator_ <= end_iterator_)
      return std::distance(begin_iterator_, end_iterator_);
    else
      return buffer_.size() - std::distance(end_iterator_, begin_iterator_);
  }
 
  T& front()
  {
    if (!full_ && (begin_iterator_ == end_iterator_))
      throw std::runtime_error("Buffer is empty");
    return *begin_iterator_;
  }
 
  T& push_back()
  {
 
    auto old_it = end_iterator_;
    if (full_)
      advance(begin_iterator_);
    advance(end_iterator_);
 
    // Buffer at max capacity
    if (end_iterator_ == begin_iterator_)
    {
      full_ = true;
    }
    return *old_it;
  }
 
  void pop_front()
  {
   if (!full_ && (begin_iterator_ == end_iterator_))
     throw std::runtime_error("Buffer is empty");
    advance(begin_iterator_);
    full_ = false;
  }
 
  VectorType &getBuffer()
  {
   return buffer_;
  }
 
private:
  void advance(typename VectorType::iterator& it, size_t distance = 1)
  {
    for (size_t i = 0; i < distance; ++i)
    {
      it++;
      if (it == buffer_.end())
        it = buffer_.begin();
    }
  }
  VectorType buffer_;
  typename VectorType::iterator begin_iterator_;
  typename VectorType::iterator end_iterator_;
  bool full_; //Disambiguates when end == begin because it's empty, or it's full
};
 
#endif // STATICCIRCULARBUFFER_H