Repo created

TMessagesProj/jni/voip/webrtc/base/containers/ring_buffer.h

@@ -0,0 +1,133 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_CONTAINERS_RING_BUFFER_H_
+#define BASE_CONTAINERS_RING_BUFFER_H_
+
+#include <stddef.h>
+
+#include "base/logging.h"
+#include "base/macros.h"
+
+namespace base {
+
+// base::RingBuffer uses a fixed-size array, unlike base::circular_deque and
+// std::deque, and so, one can access only the last |kSize| elements. Also, you
+// can add elements to the front and read/modify random elements, but cannot
+// remove elements from the back. Therefore, it does not have a |Size| method,
+// only |BufferSize|, which is a constant, and |CurrentIndex|, which is the
+// number of elements added so far.
+//
+// If the above is sufficient for your use case, base::RingBuffer should be more
+// efficient than base::circular_deque.
+template <typename T, size_t kSize>
+class RingBuffer {
+ public:
+  RingBuffer() : current_index_(0) {}
+
+  size_t BufferSize() const { return kSize; }
+
+  size_t CurrentIndex() const { return current_index_; }
+
+  // Returns true if a value was saved to index |n|.
+  bool IsFilledIndex(size_t n) const {
+    return IsFilledIndexByBufferIndex(BufferIndex(n));
+  }
+
+  // Returns the element at index |n| (% |kSize|).
+  //
+  // n = 0 returns the oldest value and
+  // n = bufferSize() - 1 returns the most recent value.
+  const T& ReadBuffer(size_t n) const {
+    const size_t buffer_index = BufferIndex(n);
+    CHECK(IsFilledIndexByBufferIndex(buffer_index));
+    return buffer_[buffer_index];
+  }
+
+  T* MutableReadBuffer(size_t n) {
+    const size_t buffer_index = BufferIndex(n);
+    CHECK(IsFilledIndexByBufferIndex(buffer_index));
+    return &buffer_[buffer_index];
+  }
+
+  void SaveToBuffer(const T& value) {
+    buffer_[BufferIndex(0)] = value;
+    current_index_++;
+  }
+
+  void Clear() { current_index_ = 0; }
+
+  // Iterator has const access to the RingBuffer it got retrieved from.
+  class Iterator {
+   public:
+    size_t index() const { return index_; }
+
+    const T* operator->() const { return &buffer_.ReadBuffer(index_); }
+    const T* operator*() const { return &buffer_.ReadBuffer(index_); }
+
+    Iterator& operator++() {
+      index_++;
+      if (index_ == kSize)
+        out_of_range_ = true;
+      return *this;
+    }
+
+    Iterator& operator--() {
+      if (index_ == 0)
+        out_of_range_ = true;
+      index_--;
+      return *this;
+    }
+
+    operator bool() const {
+      return !out_of_range_ && buffer_.IsFilledIndex(index_);
+    }
+
+   private:
+    Iterator(const RingBuffer<T, kSize>& buffer, size_t index)
+        : buffer_(buffer), index_(index), out_of_range_(false) {}
+
+    const RingBuffer<T, kSize>& buffer_;
+    size_t index_;
+    bool out_of_range_;
+
+    friend class RingBuffer<T, kSize>;
+  };
+
+  // Returns an Iterator pointing to the oldest value in the buffer.
+  // Example usage (iterate from oldest to newest value):
+  //  for (RingBuffer<T, kSize>::Iterator it = ring_buffer.Begin(); it; ++it) {}
+  Iterator Begin() const {
+    if (current_index_ < kSize)
+      return Iterator(*this, kSize - current_index_);
+    return Iterator(*this, 0);
+  }
+
+  // Returns an Iterator pointing to the newest value in the buffer.
+  // Example usage (iterate backwards from newest to oldest value):
+  //  for (RingBuffer<T, kSize>::Iterator it = ring_buffer.End(); it; --it) {}
+  Iterator End() const { return Iterator(*this, kSize - 1); }
+
+ private:
+  inline size_t BufferIndex(size_t n) const {
+    return (current_index_ + n) % kSize;
+  }
+
+  // This specialization of |IsFilledIndex| is a micro-optimization that enables
+  // us to do e.g. `CHECK(IsFilledIndex(n))` without calling |BufferIndex|
+  // twice. Since |BufferIndex| involves a % operation, it's not quite free at a
+  // micro-scale.
+  inline bool IsFilledIndexByBufferIndex(size_t buffer_index) const {
+    return buffer_index < current_index_;
+  }
+
+  T buffer_[kSize];
+  size_t current_index_;
+
+  DISALLOW_COPY_AND_ASSIGN(RingBuffer);
+};
+
+}  // namespace base
+
+#endif  // BASE_CONTAINERS_RING_BUFFER_H_