ring buffer

CMakeLists.txt

@@ -68,4 +68,9 @@ endif()
 # ------------------------------------------------------------------------------
 
 add_subdirectory(hello_world)
-# add_subdirectory(linked_list)
+add_subdirectory(ring_buffer)
+
+
+
+
+

hello_world/CMakeLists.txt

@@ -11,4 +11,3 @@ target_include_directories(HelloWorld
 )
 
 add_subdirectory(tests)
-add_subdirectory(examples)

ring_buffer/CMakeLists.txt

@@ -0,0 +1,10 @@
+add_library(RingBuffer INTERFACE)
+
+target_sources(RingBuffer
+    INTERFACE
+        FILE_SET HEADERS
+        FILES
+        ring_buffer.hpp
+)
+
+add_subdirectory(tests)

ring_buffer/ring_buffer.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <vector>
+
+namespace Containers {
+
+template <typename T> class ring_buffer {
+  size_t size_;
+  size_t begin_, end_;
+  std::vector<T> data_;
+
+public:
+  ring_buffer(size_t sz) : size_{0}, begin_{0}, end_{0} { data_.reserve(sz); }
+  size_t size() const { return size_; }
+  size_t capacity() const { return data_.capacity(); }
+
+private:
+  bool is_full() const { return size_ == capacity(); }
+  bool is_empty() const {
+    if (begin_ == end_ && !is_full())
+      return true;
+    return false;
+  }
+
+public:
+  bool push(const T &elem) {
+    if (is_full())
+      return false;
+    data_[end_++] = elem;
+    end_ %= capacity();
+    ++size_;
+    return true;
+  }
+  bool pop() {
+    if (is_empty())
+      return false;
+    ++begin_;
+    begin_ %= capacity();
+    --size_;
+    return true;
+  }
+};
+
+} // namespace Containers

ring_buffer/tests/CMakeLists.txt

@@ -0,0 +1,13 @@
+add_executable(ring_buffer_tests
+    ring_buffer_tests.cpp
+)
+
+target_link_libraries(ring_buffer_tests
+    PRIVATE
+        RingBuffer
+        #project_warnings
+        GTest::gtest_main
+)
+
+include(GoogleTest)
+gtest_discover_tests(ring_buffer_tests)

ring_buffer/tests/ring_buffer_tests.cpp

@@ -0,0 +1,40 @@
+#include "ring_buffer.hpp"
+#include <gtest/gtest.h>
+
+TEST(RingBuffer, constructor) {
+  const size_t sz = 3;
+  Containers::ring_buffer<int> rb{sz};
+  EXPECT_EQ(rb.size(), 0);
+  EXPECT_EQ(rb.capacity(), sz);
+}
+
+TEST(RingBuffer, push) {
+  const size_t sz = 2;
+  Containers::ring_buffer<int> rb{sz};
+
+  EXPECT_TRUE(rb.push(10));
+  EXPECT_EQ(rb.size(), 1);
+
+  EXPECT_TRUE(rb.push(20));
+  EXPECT_EQ(rb.size(), 2);
+
+  EXPECT_FALSE(rb.push(30));
+  EXPECT_EQ(rb.size(), 2);
+}
+
+TEST(RingBuffer, pop) {
+  const size_t sz = 2;
+  Containers::ring_buffer<int> rb{sz};
+
+  EXPECT_TRUE(rb.push(10));
+  EXPECT_TRUE(rb.push(20));
+  EXPECT_EQ(rb.size(), 2);
+
+  EXPECT_TRUE(rb.pop());
+  EXPECT_EQ(rb.size(), 1);
+
+  EXPECT_TRUE(rb.pop());
+  EXPECT_EQ(rb.size(), 0);
+
+  EXPECT_FALSE(rb.pop());
+}