ring_buffer.hpp

Go to the documentation of this file.

 
#ifndef __BOXES_RING_BUFFER_HPP__
#define __BOXES_RING_BUFFER_HPP__
 
#include "compiler.hpp"
 
#include <array>
#include <stdexcept>
 
namespace boxes {
 
template <typename T, std::size_t SizeV> class RingBuffer {
public:
  using value_type = T;
  using reference = T &;
  using const_reference = const T &;
  using size_type = std::size_t;
  using difference_type = std::ptrdiff_t;
 
  static constexpr size_type Size = SizeV;
 
  class iterator {
  public:
    using value_type = T;
    using reference = T &;
    using pointer = T *;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::random_access_iterator_tag;
 
    iterator(RingBuffer<T, SizeV> *cnt, size_type pos) : cnt{cnt}, pos{pos} {}
 
    iterator &operator++() {
      if (pos != cnt->head) {
        pos = RingBuffer<T, SizeV>::nextPos(pos);
      }
      return *this;
    }
 
    iterator operator++(int) {
      iterator tmp{*this};
      ++(*this);
      return tmp;
    }
 
    iterator &operator--() {
      if (pos != cnt->tail) {
        pos = RingBuffer<T, SizeV>::prevPos(pos);
      }
      return *this;
    }
 
    iterator operator--(int) {
      iterator tmp{*this};
      --(*this);
      return tmp;
    }
 
    reference operator*() { return cnt->buffer[pos]; }
 
    pointer operator->() { return &cnt->buffer[pos]; }
 
    bool operator==(const iterator &other) const {
      return cnt == other.cnt && pos == other.pos;
    }
 
    bool operator!=(const iterator &other) const { return !(*this == other); }
 
  private:
    RingBuffer<T, SizeV> *cnt;
    size_type pos;
  };
 
  RingBuffer() : head{0}, tail{0} {}
 
  RingBuffer(const RingBuffer<T, SizeV> &other)
      : head{other.head}, tail{other.tail}, buffer{other.buffer} {}
 
  RingBuffer(RingBuffer<T, SizeV> &&other)
      : head{other.head}, tail{other.tail}, buffer{std::move(other.buffer)} {
    other.head = 0;
    other.tail = 0;
  }
 
  RingBuffer<T, SizeV> &operator=(const RingBuffer<T, SizeV> &other) {
    if (this != &other) {
      RingBuffer<T, SizeV> tmp{other};
      swap(tmp);
    }
    return *this;
  }
 
  RingBuffer<T, SizeV> &operator=(RingBuffer<T, SizeV> &&other) {
    if (this != &other) {
      RingBuffer<T, SizeV> tmp{std::move(other)};
      swap(tmp);
    }
    return *this;
  }
 
  iterator begin() { return iterator(this, tail); }
 
  iterator end() { return iterator(this, head); }
 
  iterator cbegin() const { return begin(); }
 
  iterator cend() const { return end(); }
 
  bool empty() const BOXES_NOTHROW { return head == tail; }
 
  bool full() const BOXES_NOTHROW { return nextHead() == tail; }
 
  T &back() {
    if (empty()) {
      throw std::out_of_range("RingBuffer::front");
    }
    return buffer[prevHead()];
  }
 
  T &front() {
    if (empty()) {
      throw std::out_of_range("RingBuffer::back");
    }
    return buffer[tail];
  }
 
  const T &front() const { return const_cast<RingBuffer *>(this)->front(); }
 
  const T &back() const { return const_cast<RingBuffer *>(this)->back(); }
 
  T &operator[](size_type pos) { return buffer[(tail + pos) % BuffSize]; }
 
  const T &operator[](size_type pos) const {
    return const_cast<RingBuffer *>(this)->operator[](pos);
  }
 
  T &at(size_type pos) {
    if (pos >= size()) {
      throw std::out_of_range("RingBuffer::at");
    }
    return (*this)[pos];
  }
 
  const T &at(size_type pos) const {
    return const_cast<RingBuffer *>(this)->at(pos);
  }
 
  bool operator==(const RingBuffer<T, SizeV> &other) const {
    if (size() != other.size()) {
      return false;
    }
 
    for (size_type i = 0; i < size(); ++i) {
      if ((*this)[i] != other[i]) {
        return false;
      }
    }
 
    return true;
  }
 
  bool operator!=(const RingBuffer<T, SizeV> &other) const {
    return !(*this == other);
  }
 
  void swap(RingBuffer<T, SizeV> &other) {
    std::swap(head, other.head);
    std::swap(tail, other.tail);
    buffer.swap(other.buffer);
  }
 
  template <typename Arg> bool push_back(Arg &&value) {
    const size_type next = nextHead();
    if (next != tail) {
      buffer[head] = std::forward<Arg>(value);
      head = next;
      return true;
    }
    return false;
  }
 
  template <typename Arg> bool push_front(Arg &&value) {
    const size_type next = prevTail();
    if (next != head) {
      tail = next;
      buffer[tail] = std::forward<Arg>(value);
      return true;
    }
    return false;
  }
 
  bool pop_back() {
    if (empty()) {
      return false;
    }
    head = prevHead();
    buffer[head] = std::move(T{});
    return true;
  }
 
  bool pop_front() {
    if (empty()) {
      return false;
    }
    buffer[tail] = std::move(T{});
    tail = nextTail();
    return true;
  }
 
  size_type size() const BOXES_NOTHROW {
    if (head >= tail) {
      return head - tail;
    }
    return BuffSize - tail + head;
  }
 
  void clear() {
    while (pop_front()) {
    }
    head = 0;
    tail = 0;
  }
 
protected:
  static constexpr size_type BuffSize = Size + 1;
  size_type head;
  size_type tail;
  std::array<T, BuffSize> buffer;
 
  constexpr static size_type nextPos(size_type pos) BOXES_NOTHROW {
    return (pos + 1) % BuffSize;
  }
 
  constexpr static size_type prevPos(size_type pos) BOXES_NOTHROW {
    return (pos + BuffSize - 1) % BuffSize;
  }
 
  constexpr size_type prevHead() const BOXES_NOTHROW { return prevPos(head); }
  constexpr size_type nextHead() const BOXES_NOTHROW { return nextPos(head); }
  constexpr size_type nextTail() const BOXES_NOTHROW { return nextPos(tail); }
  constexpr size_type prevTail() const BOXES_NOTHROW { return prevPos(tail); }
};
 
} // namespace boxes
 
#endif // __BOXES_RING_BUFFER_HPP__