add preferred snake_case alias for SlickStreamBuffer, and update code references to use stream_buffer

Author: kzhdev

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## v1.0.4 - 2026-06-12
 - Separatad slick/dynamic_stream_buffer.h into slick-dynamic-buffer repo due to vcpk dependencies issue
+- Added `slick::stream_buffer` as the preferred snake_case spelling of
+  `slick::SlickStreamBuffer`, matching the `slick::stream_buffer` CMake target and the
+  Boost-style naming of the `slick::dynamic_buffer` adapter. `SlickStreamBuffer`
+  remains available for backward compatibility.
 
 ## v1.0.3 - 2026-06-11
 - `slick/dynamic_stream_buffer.h` is now installed only when Boost is found at

README.md

@@ -82,7 +82,7 @@ target_link_libraries(your_target PRIVATE slick::stream_buffer)
 #include <slick/stream_buffer.h>
 
 // 64 MB data ring, 64K message records; named -> shared memory, nullptr -> local
-slick::SlickStreamBuffer stream(1ull << 26, 1u << 16, "market_data");
+slick::stream_buffer stream(1ull << 26, 1u << 16, "market_data");
 
 for (;;) {
     auto [ptr, size] = stream.prepare(64 * 1024);
@@ -99,9 +99,9 @@ for (;;) {
 ### Consumers: independent cursors, zero-copy reads
 
 ```cpp
-// same process: share the SlickStreamBuffer instance with the producer
+// same process: share the slick::stream_buffer instance with the producer
 // another process:
-slick::SlickStreamBuffer stream("market_data");
+slick::stream_buffer stream("market_data");
 
 uint64_t cursor = stream.initial_reading_index();   // or 0 to replay history
 for (;;) {
@@ -116,7 +116,7 @@ for (;;) {
 ```cpp
 #include <slick/stream_buffer.h>
 
-slick::SlickStreamBuffer buf(1024, 16);     // capacity bytes, record count (both pow2)
+slick::stream_buffer buf(1024, 16);         // capacity bytes, record count (both pow2)
 
 auto [ptr, sz] = buf.prepare(5);
 std::memcpy(ptr, "hello", 5);
@@ -129,12 +129,16 @@ auto [data, length] = buf.read(cursor);      // -> "hello", 5
 
 ## API Overview
 
+The class is `slick::SlickStreamBuffer`; `slick::stream_buffer` is a type alias for it
+and the preferred spelling, matching the `slick::stream_buffer` CMake target. Both name
+the same type.
+
 ### Constructors
 
 ```cpp
-SlickStreamBuffer(uint64_t capacity, uint32_t control_size);                       // local memory
-SlickStreamBuffer(uint64_t capacity, uint32_t control_size, const char* shm_name); // shm creator
-SlickStreamBuffer(const char* shm_name);                                           // shm opener
+stream_buffer(uint64_t capacity, uint32_t control_size);                       // local memory
+stream_buffer(uint64_t capacity, uint32_t control_size, const char* shm_name); // shm creator
+stream_buffer(const char* shm_name);                                           // shm opener
 ```
 
 `capacity` is the data ring size in bytes; `control_size` is the number of message

include/slick/stream_buffer.h

@@ -67,9 +67,9 @@ namespace slick {
  *
  * The producer side exposes a beast::flat_buffer-like interface (prepare/commit/consume/data/size)
  * so that network bytes can be written directly into the ring (e.g. by boost::asio/boost::beast via
- * the dynamic_stream_buffer adapter). consume(n) does not discard bytes - it PUBLISHES them to
- * consumers as one discrete message record. Each consumer owns a monotonic cursor and reads whole
- * messages zero-copy as (pointer, length) pairs.
+ * the slick::dynamic_buffer adapter from the slick-dynamic-buffer repo). consume(n) does not
+ * discard bytes - it PUBLISHES them to consumers as one discrete message record. Each consumer
+ * owns a monotonic cursor and reads whole messages zero-copy as (pointer, length) pairs.
  *
  * Caveats:
  * - Producer methods (prepare/commit/consume/data/size/reset) must be called from a single thread.
@@ -696,4 +696,9 @@ class SlickStreamBuffer {
     }
 };
 
+/// Preferred snake_case spelling of SlickStreamBuffer, matching the slick::stream_buffer
+/// CMake target and the Boost-style naming of companion types such as slick::dynamic_buffer.
+/// SlickStreamBuffer remains available for backward compatibility.
+using stream_buffer = SlickStreamBuffer;
+
 }

tests/stream_buffer_shm_tests.cpp

@@ -18,11 +18,11 @@
 #include <thread>
 #include <vector>
 
-using slick::SlickStreamBuffer;
+using slick::stream_buffer;
 
 namespace {
 
-void publish_message(SlickStreamBuffer& buf, const void* src, std::size_t n) {
+void publish_message(stream_buffer& buf, const void* src, std::size_t n) {
     auto [ptr, sz] = buf.prepare(n);
     ASSERT_NE(ptr, nullptr);
     std::memcpy(ptr, src, n);
@@ -33,8 +33,8 @@ void publish_message(SlickStreamBuffer& buf, const void* src, std::size_t n) {
 }  // namespace
 
 TEST(StreamBufferShmTests, CreatorOpenerRoundtrip) {
-    SlickStreamBuffer server(1024, 16, "ssb_roundtrip");
-    SlickStreamBuffer client("ssb_roundtrip");
+    stream_buffer server(1024, 16, "ssb_roundtrip");
+    stream_buffer client("ssb_roundtrip");
     EXPECT_TRUE(server.own_buffer());
     EXPECT_FALSE(client.own_buffer());
     EXPECT_TRUE(client.use_shm());
@@ -58,23 +58,23 @@ TEST(StreamBufferShmTests, CreatorOpenerRoundtrip) {
 }
 
 TEST(StreamBufferShmTests, OpenerReadsGeometry) {
-    SlickStreamBuffer server(2048, 32, "ssb_geometry");
-    SlickStreamBuffer client("ssb_geometry");
+    stream_buffer server(2048, 32, "ssb_geometry");
+    stream_buffer client("ssb_geometry");
     EXPECT_EQ(client.capacity(), 2048u);
     EXPECT_EQ(client.control_size(), 32u);
 }
 
 TEST(StreamBufferShmTests, GeometryMismatchThrows) {
-    SlickStreamBuffer server(1024, 16, "ssb_geometry_mismatch");
+    stream_buffer server(1024, 16, "ssb_geometry_mismatch");
     EXPECT_THROW({
         try {
-            SlickStreamBuffer(2048, 16, "ssb_geometry_mismatch");
+            stream_buffer(2048, 16, "ssb_geometry_mismatch");
         } catch (const std::runtime_error& e) {
             EXPECT_TRUE(std::string(e.what()).find("geometry mismatch") != std::string::npos);
             throw;
         }
     }, std::runtime_error);
-    EXPECT_THROW(SlickStreamBuffer(1024, 32, "ssb_geometry_mismatch"), std::runtime_error);
+    EXPECT_THROW(stream_buffer(1024, 32, "ssb_geometry_mismatch"), std::runtime_error);
 }
 
 TEST(StreamBufferShmTests, MagicMismatchThrows) {
@@ -88,7 +88,7 @@ TEST(StreamBufferShmTests, MagicMismatchThrows) {
 
     EXPECT_THROW({
         try {
-            SlickStreamBuffer client("ssb_bad_magic");
+            stream_buffer client("ssb_bad_magic");
         } catch (const std::runtime_error& e) {
             EXPECT_TRUE(std::string(e.what()).find("magic mismatch") != std::string::npos);
             throw;
@@ -101,11 +101,11 @@ TEST(StreamBufferShmTests, MagicMismatchThrows) {
 }
 
 TEST(StreamBufferShmTests, LateJoinerViaShm) {
-    SlickStreamBuffer server(1024, 16, "ssb_late_joiner");
+    stream_buffer server(1024, 16, "ssb_late_joiner");
     publish_message(server, "old1", 4);
     publish_message(server, "old2", 4);
 
-    SlickStreamBuffer client("ssb_late_joiner");
+    stream_buffer client("ssb_late_joiner");
     uint64_t cursor = client.initial_reading_index();
     EXPECT_EQ(cursor, 2u);
     EXPECT_EQ(client.read(cursor).first, nullptr);
@@ -119,8 +119,8 @@ TEST(StreamBufferShmTests, LateJoinerViaShm) {
 
 #if SLICK_STREAM_BUFFER_ENABLE_LOSS_DETECTION
 TEST(StreamBufferShmTests, LossyOverwriteSkipsOldData) {
-    SlickStreamBuffer server(1024, 4, "ssb_lossy");  // tiny control ring
-    SlickStreamBuffer client("ssb_lossy");
+    stream_buffer server(1024, 4, "ssb_lossy");  // tiny control ring
+    stream_buffer client("ssb_lossy");
 
     for (uint8_t i = 0; i < 8; ++i) {
         publish_message(server, &i, 1);
@@ -136,8 +136,8 @@ TEST(StreamBufferShmTests, LossyOverwriteSkipsOldData) {
 #endif
 
 TEST(StreamBufferShmTests, ReadLastViaShm) {
-    SlickStreamBuffer server(1024, 16, "ssb_read_last");
-    SlickStreamBuffer client("ssb_read_last");
+    stream_buffer server(1024, 16, "ssb_read_last");
+    stream_buffer client("ssb_read_last");
 
     publish_message(server, "first", 5);
     publish_message(server, "second", 6);
@@ -150,11 +150,11 @@ TEST(StreamBufferShmTests, ReadLastViaShm) {
 
 TEST(StreamBufferShmTests, BroadcastTwoOpeners) {
     constexpr int kMessages = 200;
-    SlickStreamBuffer server(1 << 16, 1024, "ssb_broadcast");
-    SlickStreamBuffer client1("ssb_broadcast");
-    SlickStreamBuffer client2("ssb_broadcast");
+    stream_buffer server(1 << 16, 1024, "ssb_broadcast");
+    stream_buffer client1("ssb_broadcast");
+    stream_buffer client2("ssb_broadcast");
 
-    auto consume_all = [&](SlickStreamBuffer& client, std::vector<uint64_t>& out) {
+    auto consume_all = [&](stream_buffer& client, std::vector<uint64_t>& out) {
         uint64_t cursor = 0;
         while (out.size() < kMessages) {
             auto [ptr, len] = client.read(cursor);