updated to use updated asyncio implementation

include/wrp_sdk/asyncio/ring_buffer.hpp

@@ -0,0 +1,137 @@
+/*
+ * ring_buffer.hpp
+ *
+ * Created on: Dec 08, 2019 22:22
+ * Description:
+ *
+ * Requirements:
+ *  1. Size of buffer must be a power of 2
+ *  2. Maximum buffer size is 2^(number_of_bits_of(size_t)-1)
+ *
+ * Implementation details:
+ *
+ * - Initial state (empty)
+ * [0][1][2][3]...[N]
+ *  ^
+ * R/W
+ *
+ * - Add one element
+ * [D][1][2][3]...[N]
+ *  ^  ^
+ *  R  W
+ *
+ * - Buffer gets full when last element X is inserted
+ * [X][D][D][D]...[D]
+ *     ^
+ *    W/R (W>R)
+ *
+ * - Buffer data overwritten by new element Y after getting full
+ * [X][Y][D][D]...[D]
+ *        ^
+ *       W/R (W>R)
+ *
+ * Reference:
+ *  [1] https://embeddedartistry.com/blog/2017/05/17/creating-a-circular-buffer-in-c-and-c/
+ *  [2] https://stackoverflow.com/questions/10527581/why-must-a-ring-buffer-size-be-a-power-of-2
+ *  [3] https://stackoverflow.com/questions/9718116/improving-c-circular-buffer-efficiency
+ *  [4] https://www.snellman.net/blog/archive/2016-12-13-ring-buffers/
+ *  [5] tttp://www.trytoprogram.com/c-examples/c-program-to-test-if-a-number-is-a-power-of-2/
+ *
+ * Copyright (c) 2019 Ruixiang Du (rdu)
+ */
+
+#ifndef RING_BUFFER_HPP
+#define RING_BUFFER_HPP
+
+#include <cstdint>
+#include <cstddef>
+
+#include <array>
+
+namespace westonrobot {
+template <typename T = uint8_t, std::size_t N = 1024>
+class RingBuffer {
+ public:
+  // Init and reset of buffer
+  RingBuffer() {
+    // assert size is a power of 2
+    static_assert((N != 0) && ((N & (N - 1)) == 0), 
+        "Size of ring buffer has to be 2^n, where n is a positive integer");
+
+    size_ = N;
+    size_mask_ = size_ - 1;
+    write_index_ = 0;
+    read_index_ = 0;
+  }
+
+  void Reset() {
+    write_index_ = 0;
+    read_index_ = 0;
+  }
+
+  // Buffer size information
+  bool IsEmpty() { return (read_index_ == write_index_); }
+  bool IsFull() { return (size_ == GetOccupiedSize()); }
+
+  std::size_t GetFreeSize() const { return (size_ - GetOccupiedSize()); }
+  std::size_t GetOccupiedSize() const { return (write_index_ - read_index_); };
+
+  std::array<T, N> GetBuffer() const { return buffer_; }
+
+  // Read/Write functions
+  std::size_t Read(T data[], std::size_t btr) {
+    for (int i = 0; i < btr; ++i) {
+      if (ReadByte(&data[i]) == 0) return i;
+    }
+    return btr;
+  }
+  std::size_t Peek(T data[], std::size_t btp) {
+    for (int i = 0; i < btp; ++i) {
+      if (PeekByteAt(&data[i], i) == 0) return i;
+    }
+    return btp;
+  }
+  std::size_t Write(const T new_data[], std::size_t btw) {
+    for (int i = 0; i < btw; ++i) {
+      if (WriteByte(new_data[i]) == 0) return i;
+    }
+    return btw;
+  }
+
+  void PrintBuffer() const {
+    std::cout << "read index: " << read_index_
+              << " , write index: " << write_index_ << std::endl;
+    std::cout << "buffer content: " << std::endl;
+    for (int i = 0; i < N; ++i)
+      std::cout << "[" << i << "]"
+                << " " << static_cast<int>(buffer_[i]) << std::endl;
+  }
+
+ private:
+  std::array<T, N> buffer_;  // buffer memory to store data
+  std::size_t size_;         // size of allocated memory area
+  std::size_t size_mask_;    // for internal indexing management
+  std::size_t write_index_;  // place new data to be written
+  std::size_t read_index_;   // place earliest written data to be read from
+
+  size_t ReadByte(T *data) {
+    if (IsEmpty()) return 0;
+    *data = buffer_[read_index_++ & size_mask_];
+    return 1;
+  }
+
+  size_t PeekByteAt(T *data, size_t n) {
+    if (n >= GetOccupiedSize()) return 0;
+    *data = buffer_[(read_index_ + n) & size_mask_];
+    return 1;
+  }
+
+  size_t WriteByte(const T &new_data) {
+    if (GetOccupiedSize() == size_) return 0;
+    buffer_[(write_index_++) & size_mask_] = new_data;
+    return 1;
+  }
+};
+}  // namespace westonrobot
+
+#endif /* RING_BUFFER_HPP */