- Updating byte_buffer unittests for the templated version.

Author: avalerio-tkd

CMakeLists.txt

@@ -133,15 +133,13 @@ target_include_directories(dbps_common_lib PUBLIC
 )
 target_link_libraries(dbps_common_lib PUBLIC tcb_span)
 
-# Byte buffer processing library
-add_library(dbps_byte_buffer_lib STATIC
-  src/processing/byte_buffer.cpp
-)
-target_include_directories(dbps_byte_buffer_lib PUBLIC
+# Typed buffer processing library (header-only)
+add_library(dbps_byte_buffer_lib INTERFACE)
+target_include_directories(dbps_byte_buffer_lib INTERFACE
   src/processing
   src/common
 )
-target_link_libraries(dbps_byte_buffer_lib PUBLIC tcb_span)
+target_link_libraries(dbps_byte_buffer_lib INTERFACE tcb_span)
 
 # Server components library
 add_library(dbps_server_lib STATIC 
@@ -215,7 +213,7 @@ target_include_directories(dbps_local_lib PUBLIC
 )
 
 # Ensure PIC on static libs that are linked into shared libraries
-set_target_properties(dbps_common_lib dbps_byte_buffer_lib dbps_server_lib dbps_local_lib
+set_target_properties(dbps_common_lib dbps_server_lib dbps_local_lib
   PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
 # =============================================================================
@@ -335,13 +333,13 @@ if(BUILD_TESTS)
   )
   target_include_directories(compression_utils_test PRIVATE src/processing)
 
-  # Byte buffer tests
-  add_executable(byte_buffer_test src/processing/byte_buffer_test.cpp)
-  target_link_libraries(byte_buffer_test
+  # Typed buffer tests
+  add_executable(typed_buffer_test src/processing/typed_buffer_test.cpp)
+  target_link_libraries(typed_buffer_test
     dbps_byte_buffer_lib
     gtest_main
   )
-  target_include_directories(byte_buffer_test PRIVATE src/processing src/common)
+  target_include_directories(typed_buffer_test PRIVATE src/processing src/common)
 
   # Basic encryptor tests
   add_executable(basic_encryptor_test src/processing/encryptors/basic_encryptor_test.cpp)
@@ -536,7 +534,7 @@ if(BUILD_TESTS)
       parquet_utils_test
       bytes_utils_test
       compression_utils_test
-      byte_buffer_test
+      typed_buffer_test
       basic_encryptor_test
       auth_utils_test
       dbpa_interface_test
@@ -559,7 +557,7 @@ if(BUILD_TESTS)
   gtest_discover_tests(parquet_utils_test)
   gtest_discover_tests(bytes_utils_test)
   gtest_discover_tests(compression_utils_test)
-  gtest_discover_tests(byte_buffer_test)
+  gtest_discover_tests(typed_buffer_test)
   gtest_discover_tests(basic_encryptor_test)
   gtest_discover_tests(auth_utils_test)
   gtest_discover_tests(dbpa_interface_test)

src/processing/typed_buffer_codecs.h

@@ -126,4 +126,61 @@ struct StringVariableSizedCodec {
     }
 };
 
+struct RawBytesFixedSizedCodec {
+    using value_type = tcb::span<const uint8_t>;
+    static constexpr bool is_fixed_sized = true;
+
+    explicit RawBytesFixedSizedCodec(size_t element_size_bytes) : element_size_bytes_(element_size_bytes) {
+        if (element_size_bytes_ == 0) {
+            throw InvalidInputException("RawBytesFixedSizedCodec requires element_size_bytes > 0");
+        }
+    }
+
+    static constexpr std::string_view type_name() noexcept {
+        return "raw bytes (fixed-length)";
+    }
+
+    size_t element_size() const noexcept {
+        return element_size_bytes_;
+    }
+
+    value_type Decode(tcb::span<const uint8_t> read_span) const noexcept {
+        return read_span;
+    }
+
+    void Encode(const value_type& value, tcb::span<uint8_t> write_span) const {
+        if (value.size() != write_span.size()) {
+            throw InvalidInputException("Encode: value size does not match write_span size");
+        }
+        std::memcpy(write_span.data(), value.data(), write_span.size());
+    }
+
+    private:
+        size_t element_size_bytes_;
+};
+
+struct RawBytesVariableSizedCodec {
+    using value_type = tcb::span<const uint8_t>;
+    static constexpr bool is_fixed_sized = false;
+
+    static constexpr std::string_view type_name() noexcept {
+        return "raw bytes (variable-length)";
+    }
+
+    size_t element_size() const {
+        throw InvalidInputException("RawBytesVariableSizedCodec does not have a fixed element size");
+    }
+
+    value_type Decode(tcb::span<const uint8_t> read_span) const noexcept {
+        return read_span;
+    }
+
+    void Encode(const value_type& value, tcb::span<uint8_t> write_span) const {
+        if (value.size() != write_span.size()) {
+            throw InvalidInputException("Encode: value size does not match write_span size");
+        }
+        std::memcpy(write_span.data(), value.data(), write_span.size());
+    }
+};
+
 } // namespace dbps::processing