struct-frame 0.10.8__tar.gz → 0.10.9__tar.gz

{struct_frame-0.10.8 → struct_frame-0.10.9}/CHANGELOG.md

@@ -6,9 +6,13 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 <!-- insertion marker -->
-## [0.10.8](https://github.com/mylonics/struct-frame/releases/tag/0.10.8) - 2026-09-08
+## [0.10.9](https://github.com/mylonics/struct-frame/releases/tag/0.10.9) - 2026-10-07
 
-<small>[Compare with v0.10.7](https://github.com/mylonics/struct-frame/compare/v0.10.7...0.10.8)</small>
+<small>[Compare with v0.10.8](https://github.com/mylonics/struct-frame/compare/v0.10.8...0.10.9)</small>
+
+## [v0.10.8](https://github.com/mylonics/struct-frame/releases/tag/v0.10.8) - 2026-09-08
+
+<small>[Compare with v0.10.7](https://github.com/mylonics/struct-frame/compare/v0.10.7...v0.10.8)</small>
 
 ### Fixed
 

{struct_frame-0.10.8 → struct_frame-0.10.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: struct-frame
-Version: 0.10.8
+Version: 0.10.9
 Summary: A framework for serializing data with headers
 Project-URL: Homepage, https://github.com/mylonics/struct-frame
 Project-URL: Issues, https://github.com/mylonics/struct-frame/issues

{struct_frame-0.10.8 → struct_frame-0.10.9}/docs/src/content/docs/extended-features/cpp-sdk.md

@@ -169,5 +169,35 @@ ProfileSensorWriter sensor_writer(buffer, sizeof(buffer));
 ProfileSensorAccumulatingReader sensor_reader(get_message_info);
 ```
 
-See [Framing Details](/basic-usage/framing-details/) for more profiles.
+### Contiguous buffer overloads
+
+The C++ APIs retain their pointer-and-length overloads and also accept any
+contiguous buffer exposing `data()` and `size()`. This includes
+`std::array`, `std::span`, `etl::array`, and `etl::span` when those libraries
+are available:
+
+```cpp
+#include <array>
+#include <span>
+
+std::array<uint8_t, 1024> storage{};
+auto encoded = FrameEncoderWithCrc<ProfileStandardConfig>::encode(storage, msg);
+
+std::span<const uint8_t> frame(storage.data(), encoded);
+auto parsed = BufferParserWithCrc<ProfileStandardConfig>::parse(frame, get_message_info);
 
+BasicTypesMessage decoded{};
+decoded.deserialize(frame.subspan(parsed.msg_data - frame.data(), parsed.msg_len));
+
+ProfileStandardWriter writer(storage);
+writer.write(msg);
+ProfileStandardReader reader(frame, get_message_info);
+```
+
+The same overloads are available on generated message `serialize`/`deserialize`,
+`BufferWriter`, `BufferReader`, `AccumulatingReader::add_data`, frame checksum
+helpers, SDK `Feed`/`SendRaw`, and transport `Send`. These overloads do not
+allocate or change the existing raw-pointer APIs, so ETL containers and views
+can be used without conversions.
+
+See [Framing Details](/basic-usage/framing-details/) for more profiles.

{struct_frame-0.10.8 → struct_frame-0.10.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "struct-frame"
-version = "0.10.8"
+version = "0.10.9"
 authors = [
   { name="Rijesh Augustine", email="rijesh@mylonics.com" },
 ]

{struct_frame-0.10.8 → struct_frame-0.10.9}/src/struct_frame/boilerplate/cpp/frame_base.hpp

@@ -48,6 +48,15 @@ inline FrameChecksum fletcher_checksum(const uint8_t* data, size_t length, uint8
   return ck;
 }
 
+template <typename Buffer>
+  requires requires(const Buffer& buffer) {
+    buffer.data();
+    buffer.size();
+  }
+inline FrameChecksum fletcher_checksum(const Buffer& data, uint8_t magic1 = 0, uint8_t magic2 = 0) {
+  return fletcher_checksum(data.data(), data.size(), magic1, magic2);
+}
+
 // Extension-aware Fletcher-16 checksum.
 // Computes: Fletcher(data[0..base_len]) → mix magic1/magic2 → Fletcher(data[base_len..total_len]).
 // When base_len == total_len the result is identical to fletcher_checksum.
@@ -58,6 +67,7 @@ inline FrameChecksum fletcher_checksum_ext(const uint8_t* data, size_t base_len,
     ck.byte1 = static_cast<uint8_t>(ck.byte1 + data[i]);
     ck.byte2 = static_cast<uint8_t>(ck.byte2 + ck.byte1);
   }
+
   ck.byte1 = static_cast<uint8_t>(ck.byte1 + magic1);
   ck.byte2 = static_cast<uint8_t>(ck.byte2 + ck.byte1);
   ck.byte1 = static_cast<uint8_t>(ck.byte1 + magic2);
@@ -69,6 +79,16 @@ inline FrameChecksum fletcher_checksum_ext(const uint8_t* data, size_t base_len,
   return ck;
 }
 
+template <typename Buffer>
+  requires requires(const Buffer& buffer) {
+    buffer.data();
+    buffer.size();
+  }
+inline FrameChecksum fletcher_checksum_ext(const Buffer& data, size_t base_len, uint8_t magic1 = 0,
+                                           uint8_t magic2 = 0) {
+  return fletcher_checksum_ext(data.data(), base_len, data.size(), magic1, magic2);
+}
+
 // Parse result status.
 //
 // Buffer parsers (BufferParserWithCrc/BufferParserMinimal) report on failure:

{struct_frame-0.10.8 → struct_frame-0.10.9}/src/struct_frame/boilerplate/cpp/frame_profiles.hpp

@@ -192,6 +192,11 @@ class FrameEncoderWithCrc {
 
     return idx;
   }
+
+  template <typename Buffer, FramedMessage T>
+  static size_t encode(Buffer& buffer, const T& msg, uint8_t seq = 0, uint8_t sys_id = 0, uint8_t comp_id = 0) {
+    return encode(buffer.data(), buffer.size(), msg, seq, sys_id, comp_id);
+  }
 };
 
 /**
@@ -248,6 +253,11 @@ class FrameEncoderMinimal {
 
     return idx;
   }
+
+  template <typename Buffer, FramedMessage T>
+  static size_t encode(Buffer& buffer, const T& msg) {
+    return encode(buffer.data(), buffer.size(), msg);
+  }
 };
 
 /**
@@ -358,6 +368,11 @@ class BufferParserWithCrc {
     return FrameMsgInfo(true, msg_id, msg_len, total_size,
                         buffer + Config::header_size, buffer);
   }
+
+  template <typename Buffer, typename GetMessageInfoFn = std::nullptr_t>
+  static FrameMsgInfo parse(const Buffer& buffer, GetMessageInfoFn get_message_info = nullptr) {
+    return parse(buffer.data(), buffer.size(), get_message_info);
+  }
 };
 
 /**
@@ -433,6 +448,11 @@ class BufferParserMinimal {
     r.status = FrameMsgStatus::WaitingForStart;
     return r;
   }
+
+  template <typename Buffer, typename GetMessageInfoFn = std::nullptr_t>
+  static FrameMsgInfo parse(const Buffer& buffer, GetMessageInfoFn get_message_info = nullptr) {
+    return parse(buffer.data(), buffer.size(), get_message_info);
+  }
 };
 
 /*===========================================================================
@@ -493,6 +513,13 @@ class BufferReader {
   BufferReader(const uint8_t* buffer, size_t size, GetMessageInfoFn get_message_info)
       : buffer_(buffer), size_(size), offset_(0), get_message_info_(get_message_info) {}
 
+  template <typename Buffer>
+  explicit BufferReader(const Buffer& buffer) : BufferReader(buffer.data(), buffer.size()) {}
+
+  template <typename Buffer>
+  BufferReader(const Buffer& buffer, GetMessageInfoFn get_message_info)
+      : BufferReader(buffer.data(), buffer.size(), get_message_info) {}
+
   /**
    * Parse the next frame in the buffer.
    * Returns FrameMsgInfo with valid=true if successful, valid=false if no more frames.
@@ -603,6 +630,9 @@ class BufferWriter {
  public:
   BufferWriter(uint8_t* buffer, size_t capacity) : buffer_(buffer), capacity_(capacity), offset_(0) {}
 
+  template <typename Buffer>
+  explicit BufferWriter(Buffer& buffer) : BufferWriter(buffer.data(), buffer.size()) {}
+
   /**
    * Write a message to the buffer.
    * Returns the number of bytes written, or 0 on failure.
@@ -803,6 +833,11 @@ class AccumulatingReader {
     }
   }
 
+  template <typename Buffer>
+  void add_data(const Buffer& buffer) {
+    add_data(buffer.data(), buffer.size());
+  }
+
   /**
    * Parse the next frame (buffer mode).
    * Returns FrameMsgInfo with valid=true if successful, valid=false if no more complete frames.

{struct_frame-0.10.8 → struct_frame-0.10.9}/src/struct_frame/boilerplate/cpp/struct_frame_sdk/struct_frame_sdk.hpp

@@ -355,6 +355,11 @@ class StructFrameSdkT : public IStructFrameSdk {
     ParseBuffer();
   }
 
+  template <typename Buffer>
+  void Feed(const Buffer& data) {
+    Feed(data.data(), data.size());
+  }
+
   // -----------------------------------------------------------------------
   // Send
   // -----------------------------------------------------------------------
@@ -405,6 +410,11 @@ class StructFrameSdkT : public IStructFrameSdk {
     return SendResult{written == framedLen, framedLen, written};
   }
 
+  template <typename Buffer>
+  SendResult SendRaw(uint16_t msgId, const Buffer& data) {
+    return SendRaw(msgId, data.data(), data.size());
+  }
+
   /**
    * Forward a parsed FrameMsgInfo through this SDK's transport.
    *

{struct_frame-0.10.8 → struct_frame-0.10.9}/src/struct_frame/boilerplate/cpp/struct_frame_sdk/transport.hpp

@@ -128,6 +128,9 @@ public:
      * @return Number of bytes sent.
      */
     size_t Send(const uint8_t*, size_t) { return 0; }
+
+    template <typename Buffer>
+    size_t Send(const Buffer& data) { return Send(data.data(), data.size()); }
 };
 
 } // namespace sdk

{struct_frame-0.10.8 → struct_frame-0.10.9}/src/struct_frame/cpp_gen.py

@@ -615,6 +615,10 @@ class MessageCppGen():
         
         result += f'        return offset;\n'
         result += f'    }}\n'
+        result += f'\n    template <typename Buffer>\n'
+        result += f'    size_t serialize(Buffer& buffer) const {{\n'
+        result += f'        return serialize(buffer.data());\n'
+        result += f'    }}\n'
         
         # Generate _deserialize_variable method (was unpack_variable, now private)
         result += f'\n    /**\n'
@@ -784,6 +788,10 @@ class MessageCppGen():
         result += f'    size_t deserialize(const structframe::FrameMsgInfo& frame_info) {{\n'
         result += f'        return deserialize(frame_info.msg_data, frame_info.msg_len);\n'
         result += f'    }}\n'
+        result += f'\n    template <typename Buffer>\n'
+        result += f'    size_t deserialize(const Buffer& buffer) {{\n'
+        result += f'        return deserialize(buffer.data(), buffer.size());\n'
+        result += f'    }}\n'
         
         # Add serialize method for non-variable messages (simple case)
         if not msg.variable:
@@ -796,6 +804,10 @@ class MessageCppGen():
             result += f'        std::memcpy(buffer, this, MAX_SIZE);\n'
             result += f'        return MAX_SIZE;\n'
             result += f'    }}\n'
+            result += f'\n    template <typename Buffer>\n'
+            result += f'    size_t serialize(Buffer& buffer) const {{\n'
+            result += f'        return serialize(buffer.data());\n'
+            result += f'    }}\n'
         
         return result
 

{struct_frame-0.10.8 → struct_frame-0.10.9}/tests/cpp/test_sdk_subscribe.cpp

@@ -11,6 +11,8 @@
 
 #include <cstdio>
 #include <cstring>
+#include <array>
+#include <span>
 #include <vector>
 
 // Generated message types
@@ -311,13 +313,13 @@ bool test_end_to_end_parse_pipeline() {
   msg.regular_int = 777;
   msg.flag = false;
 
-  uint8_t encoded[512];
+  std::array<uint8_t, 512> encoded{};
   size_t frame_len =
-      FrameEncoderWithCrc<ProfileStandardConfig>::encode(encoded, sizeof(encoded), msg);
+      FrameEncoderWithCrc<ProfileStandardConfig>::encode(encoded, msg);
   if (frame_len == 0) return false;
 
-  // Inject the complete frame via the transport
-  transport.inject_data(encoded, frame_len);
+  // Feed the complete frame through the SDK using a span view.
+  sdk.Feed(std::span<const uint8_t>(encoded.data(), frame_len));
 
   // Subscriber must have been called with the correct decoded values
   if (dispatch_count != 1) return false;
@@ -609,10 +611,10 @@ bool test_send_raw_returns_success_result() {
 
   BasicTypesMessage msg{};
   msg.regular_int = 99;
-  uint8_t payload[BasicTypesMessage::MAX_SIZE];
+  std::array<uint8_t, BasicTypesMessage::MAX_SIZE> payload{};
   msg.serialize(payload);
 
-  SendResult result = sdk.SendRaw(BasicTypesMessage::MSG_ID, payload, BasicTypesMessage::MAX_SIZE);
+  SendResult result = sdk.SendRaw(BasicTypesMessage::MSG_ID, payload);
 
   if (!result.success) return false;
   if (result.attempted_bytes == 0) return false;

{struct_frame-0.10.8 → struct_frame-0.10.9}/tests/cpp/test_sdk_units.cpp

@@ -10,6 +10,8 @@
 
 #include <cstdio>
 #include <cstring>
+#include <array>
+#include <span>
 #include <vector>
 
 #include "include/standard_messages.hpp"
@@ -410,6 +412,42 @@ bool test_parser_minimal_rejects_truncated() {
   return !result.valid;
 }
 
+bool test_std_array_and_span_overloads() {
+  BasicTypesMessage msg = StandardMessages::create_basic_types(
+      1, 2, 3, 4, 5u, 6u, 7u, 8u, 1.0f, 2.0, true, "array", "span");
+  std::array<uint8_t, 512> frame{};
+  const size_t encoded = FrameEncoderWithCrc<ProfileStandardConfig>::encode(frame, msg);
+  if (encoded == 0) return false;
+
+  const std::span<const uint8_t> view(frame.data(), encoded);
+  auto result = BufferParserWithCrc<ProfileStandardConfig>::parse(view, get_message_info);
+  if (!result.valid || result.msg_len != BasicTypesMessage::MAX_SIZE) return false;
+
+  BasicTypesMessage decoded{};
+  std::span<const uint8_t> payload(result.msg_data, result.msg_len);
+  if (decoded.deserialize(payload) != result.msg_len || decoded.small_int != 1) return false;
+
+  std::array<uint8_t, 512> written{};
+  BufferWriter<ProfileStandardConfig> writer(written);
+  if (writer.write(msg) != encoded || writer.size() != encoded) return false;
+
+  BufferReader<ProfileStandardConfig, decltype(&get_message_info)> reader(
+      std::span<const uint8_t>(written.data(), writer.size()), get_message_info);
+  auto read_result = reader.next();
+  if (!read_result.valid || read_result.msg_len != BasicTypesMessage::MAX_SIZE) return false;
+
+  AccumulatingReader<ProfileStandardConfig, 1024, decltype(&get_message_info)> accumulating(
+      get_message_info);
+  accumulating.add_data(std::span<const uint8_t>(written.data(), writer.size()));
+  auto accumulated_result = accumulating.next();
+  if (!accumulated_result.valid || accumulated_result.msg_len != BasicTypesMessage::MAX_SIZE) return false;
+  const auto span_checksum = fletcher_checksum(
+      std::span<const uint8_t>(written.data(), writer.size()));
+  const auto pointer_checksum = fletcher_checksum(written.data(), writer.size());
+  return span_checksum.byte1 == pointer_checksum.byte1 &&
+         span_checksum.byte2 == pointer_checksum.byte2;
+}
+
 // ============================================================================
 // Test runner
 // ============================================================================
@@ -474,6 +512,8 @@ int main() {
            test_parser_minimal_rejects_unknown_id);
   run_test("BufferParserMinimal: rejects truncated frame",
            test_parser_minimal_rejects_truncated);
+   run_test("std::array/std::span buffer overloads",
+            test_std_array_and_span_overloads);
 
   printf("\n========================================\n");
   printf("Summary: %d/%d tests passed\n", tests_passed, tests_run);