circularbuffer.h

Go to the documentation of this file.

#ifndef ION_BASE_CIRCULARBUFFER_H_
#define ION_BASE_CIRCULARBUFFER_H_

#include "ion/base/stlalloc/allocunorderedmap.h"
#include "ion/base/stlalloc/allocvector.h"

namespace ion {
namespace base {

template<typename T>
class CircularBuffer : public ion::base::Allocatable {
 public:
  CircularBuffer(
      size_t capacity, const ion::base::AllocatorPtr& alloc, bool do_reserve);

  void AddItem(const T& item) {
    if (buffer_.size() < capacity_) {
      buffer_.push_back(item);
    } else {
      buffer_[next_pos_] = item;
    }
    next_pos_ = (next_pos_ + 1) % capacity_;
  }

  const T& GetItem(size_t i) const {
    DCHECK(i < buffer_.size());
    DCHECK(i < capacity_);
    if (buffer_.size() < capacity_) {
      return buffer_[i];
    } else {
      size_t wrap_threshold = capacity_ - next_pos_;
      if (i < wrap_threshold) {
        return buffer_[i + next_pos_];
      } else {
        return buffer_[i - wrap_threshold];
      }
    }
  }

  size_t GetSize() const { return std::min(buffer_.size(), capacity_); }

  size_t GetCapacity() const { return capacity_; }

 private:
  const size_t capacity_;

  size_t next_pos_;

  ion::base::AllocVector<T> buffer_;
};

template<typename T>
CircularBuffer<T>::CircularBuffer(
    size_t capacity, const ion::base::AllocatorPtr& alloc, bool do_reserve)
    : capacity_(capacity), next_pos_(0), buffer_(alloc) {
  if (do_reserve) {
    buffer_.reserve(capacity_);
  }
}

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_CIRCULARBUFFER_H_