Enhance ring buffer implementation with additional features and tests

bugparty · bugparty · commit 002c14f8d36a · 2026-01-18T01:51:30.000-08:00
- Updated CMakeLists.txt to define project and include Google Test conditionally.
- Expanded .gitignore to include build artifacts and temporary testing files.
- Improved RingBuffer class with move semantics, swap functionality, and additional iterator methods.
- Added comprehensive unit tests for copy behavior, iterator equality, and buffer state after operations.
- Updated README with FetchContent integration instructions and testing policy.
diff --git a/.gitignore b/.gitignore
@@ -1,3 +1,6 @@
 .idea
 cmake-build-debug
 cmake-build-release
+build
+Testing/Temporary
+
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.21)
-project(RingBufferTest)
+project(RingBuffer LANGUAGES CXX)
 
 set(Simulate_Android_ToolChain OFF)
 if (Simulate_Android_ToolChain)
@@ -9,19 +9,23 @@ else()
     set(CMAKE_CXX_STANDARD 17)
 endif()
 
-# Add Google Test
-# Include FetchContent to download and manage external dependencies
-include(FetchContent)
-FetchContent_Declare(
-  googletest
-  URL https://github.com/google/googletest/archive/refs/tags/release-1.11.0.zip
-)
-FetchContent_MakeAvailable(googletest)
+add_library(RingBuffer INTERFACE)
+add_library(RingBuffer::RingBuffer ALIAS RingBuffer)
+target_include_directories(RingBuffer INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
 
-enable_testing()
-add_executable(RingBufferTest test_main.cpp)
-target_link_libraries(RingBufferTest gtest gtest_main)
+option(RINGBUFFER_BUILD_TESTS "Build RingBuffer tests" ON)
+if (RINGBUFFER_BUILD_TESTS)
+    include(FetchContent)
+    FetchContent_Declare(
+      googletest
+      URL https://github.com/google/googletest/archive/refs/tags/release-1.11.0.zip
+    )
+    FetchContent_MakeAvailable(googletest)
 
+    enable_testing()
+    add_executable(RingBufferTest test_main.cpp)
+    target_link_libraries(RingBufferTest gtest gtest_main RingBuffer::RingBuffer)
 
-include(GoogleTest)
-gtest_discover_tests(RingBufferTest)
+    include(GoogleTest)
+    gtest_discover_tests(RingBufferTest)
+endif()
diff --git a/README.md b/README.md
@@ -46,8 +46,8 @@ This project demonstrates many modern C++ best practices:
 ### Build Instructions
 
 ```bash
-git clone https://github.com/yourusername/RingBuffer.git
-cd RingBuffer
+git clone https://github.com/bugparty/RingBufferCpp.git
+cd RingBufferCpp
 mkdir build && cd build
 cmake ..
 cmake --build .
@@ -60,6 +60,39 @@ This will:
 
 ---
 
+## FetchContent Integration
+
+```cmake
+include(FetchContent)
+FetchContent_Declare(
+  RingBuffer
+  GIT_REPOSITORY https://github.com/bugparty/RingBufferCpp.git
+  GIT_TAG main
+)
+FetchContent_MakeAvailable(RingBuffer)
+
+target_link_libraries(your_target PRIVATE RingBuffer::RingBuffer)
+```
+
+To skip building tests in your parent project, set:
+
+```cmake
+set(RINGBUFFER_BUILD_TESTS OFF)
+```
+
+---
+
+## Testing Policy
+
+When changing the library, run the tests before pushing changes:
+
+```bash
+cmake --build build
+ctest --output-on-failure --test-dir build
+```
+
+---
+
 Usage
 
 ```cpp
diff --git a/RingBuffer.hpp b/RingBuffer.hpp
@@ -7,6 +7,7 @@
 #include <type_traits>
 #include <algorithm>
 #include <cstring>
+#include <utility>
 #include <vector>
 #pragma once
 namespace buffers {
@@ -62,12 +63,12 @@ namespace buffers {
             [[nodiscard]] const_pointer operator->() const noexcept {
                 return &((*source_)[index_]);
             }
-            [[nodiscard]] self_type& operator++() noexcept {
+            self_type& operator++() noexcept {
                 index_ = ++index_ % N;
                 ++count_;
                 return *this;
             }
-            [[nodiscard]] self_type operator++(int) noexcept {
+            self_type operator++(int) noexcept {
                 auto result = *this;
                 ++(*this);
                 return result;
@@ -78,6 +79,9 @@ namespace buffers {
             [[nodiscard]] size_type count() const noexcept {
                 return count_;
             }
+            [[nodiscard]] buffer_t source() const noexcept {
+                return source_;
+            }
             ~ring_buffer_iterator() = default;
         private:
             buffer_t source_{};
@@ -88,13 +92,13 @@ namespace buffers {
         template<typename T, size_t N, bool C, bool Overwrite>
         bool operator==(ring_buffer_iterator<T,N,C,Overwrite> const& l,
                         ring_buffer_iterator<T,N,C,Overwrite> const& r) noexcept {
-            return l.count() == r.count();
+            return l.source() == r.source() && l.count() == r.count() && l.index() == r.index();
         }
 
         template<typename T, size_t N, bool C, bool Overwrite>
         bool operator!=(ring_buffer_iterator<T,N,C,Overwrite> const& l,
                         ring_buffer_iterator<T,N,C,Overwrite> const& r) noexcept {
-            return l.count() != r.count();
+            return l.source() != r.source() || l.count() != r.count() || l.index() != r.index();
         }
 
     }
@@ -134,11 +138,14 @@ using std::bool_constant;
         using iterator = detail::ring_buffer_iterator<T, N, false, Overwrite>;
         using const_iterator = detail::ring_buffer_iterator<T, N, true, Overwrite>;
 
+        // Create an empty ring buffer.
         ring_buffer() noexcept = default;
+        // Copy contents and state from another buffer.
         ring_buffer(ring_buffer const& rhs) noexcept(is_nothrow_copy_constructible_v<value_type>)
         {
             copy_impl(rhs, bool_constant<is_trivially_copyable_v<T>>{});
         }
+        // Assign from another buffer.
         ring_buffer& operator=(ring_buffer const& rhs) noexcept(is_nothrow_copy_constructible_v<value_type>) {
             if(this == &rhs)
                 return *this;
@@ -148,10 +155,31 @@ using std::bool_constant;
 
             return *this;
         }
+        // Move contents and state from another buffer.
+        ring_buffer(ring_buffer&& rhs) noexcept(std::is_nothrow_move_constructible<value_type>::value)
+        {
+            move_impl(rhs, bool_constant<is_trivially_copyable_v<T>>{});
+        }
+        // Move-assign from another buffer.
+        ring_buffer& operator=(ring_buffer&& rhs) noexcept(std::is_nothrow_move_constructible<value_type>::value) {
+            if(this == &rhs)
+                return *this;
+
+            destroy_all(bool_constant<is_trivially_copyable_v<T>>{});
+            move_impl(rhs, bool_constant<is_trivially_copyable_v<T>>{});
+
+            return *this;
+        }
+        // Swap contents with another buffer.
+        void swap(self_type& rhs) noexcept(noexcept(swap_impl(rhs, bool_constant<is_trivially_copyable_v<T>>{}))) {
+            swap_impl(rhs, bool_constant<is_trivially_copyable_v<T>>{});
+        }
+        // Append an element, overwriting when configured.
         template<typename U>
         void push_back(U&& value) {
             push_back(std::forward<U>(value), bool_constant<Overwrite>{});
         }
+        // Remove the oldest element if present.
         void pop_front() noexcept{
             if(empty())
                 return;
@@ -161,36 +189,52 @@ using std::bool_constant;
             --size_;
             tail_ = ++tail_ %N;
         }
+        // Access the newest element.
         [[nodiscard]] reference back() noexcept {
             return reinterpret_cast<reference>(elements_[(head_ + N - 1) % N]);
         }
+        // Access the newest element (const).
         [[nodiscard]] const_reference back() const noexcept {
             return const_cast<self_type*>(this)->back();
         }
+        // Access the oldest element.
         [[nodiscard]] reference front() noexcept { return reinterpret_cast<reference >(elements_[tail_]); }
+        // Access the oldest element (const).
         [[nodiscard]] const_reference front() const noexcept {
             return const_cast<self_type*>(this)->front();
         }
+        // Direct access by internal storage index.
         [[nodiscard]] reference operator[](size_type index) noexcept {
             return reinterpret_cast<reference >(elements_[index]);
         }
+        // Direct access by internal storage index (const).
         [[nodiscard]] const_reference operator[](size_type index) const noexcept {
             return const_cast<self_type *>(this)->operator[](index);
         }
+        // Iterator to oldest element.
         [[nodiscard]] iterator begin() noexcept { return iterator{this, tail_, 0};}
+        // Iterator to one past newest element.
         [[nodiscard]] iterator end() noexcept { return iterator{this, head_, size_};}
+        // Const iterator to oldest element.
         [[nodiscard]] const_iterator cbegin() const noexcept { return const_iterator{this, tail_, 0};}
+        // Const iterator to one past newest element.
         [[nodiscard]] const_iterator cend() const noexcept { return const_iterator{this, head_, size_};}
+        // Check if buffer has no elements.
         [[nodiscard]] bool empty() const noexcept { return size_ == 0; }
+        // Check if buffer is at capacity.
         [[nodiscard]] bool full() const noexcept { return size_ == N; }
+        // Current element count.
         [[nodiscard]] size_type size() const noexcept { return size_; }
+        // Maximum element count.
         [[nodiscard]] size_type capacity() const noexcept { return N; }
+        // Remove all elements and reset indices.
        void clear() noexcept {
             destroy_all(bool_constant<is_trivially_destructible_v<value_type>>{});
             size_ = 0;
             head_ = 0;
             tail_ = 0;
         }
+        // Destroy elements on teardown.
         ~ring_buffer() {
             clear();
         };
@@ -204,7 +248,7 @@ using std::bool_constant;
             }
         }
         void copy_impl(self_type const& rhs, std::true_type) {
-            std::memcpy(elements_, rhs.elements_, rhs.size_ * sizeof(T));
+            std::memcpy(elements_, rhs.elements_, N * sizeof(T));
             size_ = rhs.size_;
             tail_ = rhs.tail_;
             head_ = rhs.head_;
@@ -248,6 +292,59 @@ using std::bool_constant;
 
 #endif
         }
+        void move_impl(self_type& rhs, std::true_type) {
+            std::memcpy(elements_, rhs.elements_, N * sizeof(T));
+            size_ = rhs.size_;
+            tail_ = rhs.tail_;
+            head_ = rhs.head_;
+            rhs.clear();
+        }
+        void move_impl(self_type& rhs, std::false_type) {
+            tail_ = rhs.tail_;
+            head_ = rhs.head_;
+            size_ = rhs.size_;
+#ifdef __cpp_exceptions
+            try {
+                for (auto i = 0; i < size_; ++i)
+                    new( elements_ + ((tail_ + i) % N)) T(std::move(rhs[(tail_ + i) % N]));
+            }catch(...) {
+                while(!empty()) {
+                    destroy(tail_, bool_constant<std::is_trivially_destructible_v<value_type>>{});
+                    tail_ = ++tail_ % N;
+                    --size_;
+                }
+                throw;
+            }
+#else
+            storage_type *p = nullptr;
+            for (auto i = 0; i < size_; ++i) {
+                p =reinterpret_cast<storage_type *>(new(elements_ + ((tail_ + i) % N)) T(std::move(rhs[(tail_ + i) % N])));
+                if (!p) {
+                    break;
+                }
+            }
+            if (!p) {
+                while(!empty()) {
+                    destroy(tail_, bool_constant<is_trivially_destructible_v<value_type>>{});
+                    tail_ = ++tail_ % N;
+                    --size_;
+                }
+            }
+#endif
+            rhs.clear();
+        }
+        void swap_impl(self_type& rhs, std::true_type) noexcept {
+            std::swap(elements_, rhs.elements_);
+            std::swap(head_, rhs.head_);
+            std::swap(tail_, rhs.tail_);
+            std::swap(size_, rhs.size_);
+        }
+        void swap_impl(self_type& rhs, std::false_type) {
+            self_type temp;
+            temp.move_impl(*this, std::false_type{});
+            this->move_impl(rhs, std::false_type{});
+            rhs.move_impl(temp, std::false_type{});
+        }
         template<typename U>
         void push_back(U&& value, std::true_type) {
             push_back_impl(std::forward<U>(value));
@@ -284,5 +381,10 @@ using std::bool_constant;
         size_type size_{};
     };
 
+    template<typename T, size_t N, bool Overwrite>
+    void swap(ring_buffer<T, N, Overwrite>& lhs, ring_buffer<T, N, Overwrite>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+        lhs.swap(rhs);
+    }
+
 }
 #endif //RINGBUFFERTEST_RINGBUFFER_HPP
diff --git a/test_main.cpp b/test_main.cpp
