struct-frame 0.0.25__py3-none-any.whl → 0.0.28__py3-none-any.whl

struct_frame/py_gen.py

@@ -17,6 +17,7 @@ py_types = {"uint8": "uint8",
             "double": "float64",
             "uint64": 'uint64',
             "int64":  'int64',
+            "string": "str",  # Add string type support
             }
 
 
@@ -58,14 +59,51 @@ class FieldPyGen():
 
         var_name = field.name
         type_name = field.fieldType
+
+        # Handle basic type resolution
         if type_name in py_types:
-            type_name = py_types[type_name]
+            base_type = py_types[type_name]
         else:
-            type_name = '%s%s' % (pascalCase(field.package), type_name)
             if field.isEnum:
-                type_name = 'uint8 #%s' % type_name
+                # For enums, use the full enum class name for better type safety
+                base_type = '%s%s' % (pascalCase(field.package), type_name)
+            else:
+                base_type = '%s%s' % (pascalCase(field.package), type_name)
+
+        # Handle arrays
+        if field.is_array:
+            if field.fieldType == "string":
+                # String arrays require both array size and individual element size
+                if field.size_option is not None:
+                    type_annotation = f"list[{base_type}]  # Fixed string array size={field.size_option}, each max {field.element_size} chars"
+                elif field.max_size is not None:
+                    type_annotation = f"list[{base_type}]  # Bounded string array max_size={field.max_size}, each max {field.element_size} chars"
+                else:
+                    type_annotation = f"list[{base_type}]  # String array"
+            else:
+                # Non-string arrays
+                if field.size_option is not None:
+                    type_annotation = f"list[{base_type}]  # Fixed array size={field.size_option}"
+                elif field.max_size is not None:
+                    type_annotation = f"list[{base_type}]  # Bounded array max_size={field.max_size}"
+                else:
+                    type_annotation = f"list[{base_type}]  # Array"
+        # Handle strings with size info
+        elif field.fieldType == "string":
+            if field.size_option is not None:
+                # Fixed string - exact length
+                type_annotation = f"str  # Fixed string size={field.size_option}"
+            elif field.max_size is not None:
+                # Variable string - up to max length
+                type_annotation = f"str  # Variable string max_size={field.max_size}"
+            else:
+                # Fallback (shouldn't happen with validation)
+                type_annotation = "str  # String"
+        else:
+            # Regular field
+            type_annotation = base_type
 
-        result += '    %s: %s' % (var_name, type_name)
+        result += '    %s: %s' % (var_name, type_annotation)
 
         leading_comment = field.comments
         if leading_comment:
@@ -86,7 +124,7 @@ class MessagePyGen():
                 result = '#%s\n' % c
 
         structName = '%s%s' % (pascalCase(msg.package), msg.name)
-        result += 'class %s(Structured):\n' % structName
+        result += 'class %s(Structured, byte_order=ByteOrder.LE, byte_order_mode=ByteOrderMode.OVERRIDE):\n' % structName
         result += '    msg_size = %s\n' % msg.size
         if msg.id != None:
             result += '    msg_id = %s\n' % msg.id
@@ -94,7 +132,42 @@ class MessagePyGen():
         result += '\n'.join([FieldPyGen.generate(f)
                             for key, f in msg.fields.items()])
 
-        return result + '\n'
+        result += '\n\n    def __str__(self):\n'
+        result += f'        out = "{msg.name} Msg, ID {msg.id}, Size {msg.size} \\n"\n'
+        for key, f in msg.fields.items():
+            result += f'        out += f"{key} = '
+            result += '{self.' + key + '}\\n"\n'
+        result += f'        out += "\\n"\n'
+        result += f'        return out'
+
+        result += '\n\n    def to_dict(self, include_name = True, include_id = True):\n'
+        result += '        out = {}\n'
+        # Handle all field types including arrays
+        for key, f in msg.fields.items():
+            if f.is_array:
+                if f.isDefaultType or f.isEnum or f.fieldType == "string":
+                    # Array of primitives, enums, or strings
+                    result += f'        out["{key}"] = self.{key}\n'
+                else:
+                    # Array of nested messages - convert each element
+                    result += f'        out["{key}"] = [item.to_dict(False, False) for item in self.{key}]\n'
+            elif f.isDefaultType or f.isEnum or f.fieldType == "string":
+                # Regular primitive, enum, or string field
+                result += f'        out["{key}"] = self.{key}\n'
+            else:
+                # Nested message field
+                if getattr(f, 'flatten', False):
+                    # Merge nested dict into parent
+                    result += f'        out.update(self.{key}.to_dict(False, False))\n'
+                else:
+                    result += f'        out["{key}"] = self.{key}.to_dict(False, False)\n'
+        result += '        if include_name:\n'
+        result += f'            out["name"] = "{msg.name}"\n'
+        result += '        if include_id:\n'
+        result += f'            out["msg_id"] = "{msg.id}"\n'
+        result += '        return out\n'
+
+        return result
 
     @staticmethod
     def get_initializer(msg, null_init):

struct_frame/ts_gen.py

@@ -18,6 +18,23 @@ ts_types = {
     "uint32": 'UInt32LE',
     "uint64": 'BigInt64LE',
     "int64":  'BigUInt64LE',
+    "string":   'String',
+}
+
+# TypeScript type mappings for array declarations
+ts_array_types = {
+    "int8":     'number',
+    "uint8":    'number',
+    "int16":    'number',
+    "uint16":   'number',
+    "bool":     'boolean',
+    "double":   'number',
+    "float":    'number',
+    "int32":    'number',
+    "uint32":   'number',
+    "uint64":   'bigint',
+    "int64":    'bigint',
+    "string":   'string',
 }
 
 
@@ -65,18 +82,66 @@ class FieldTsGen():
     def generate(field, packageName):
         result = ''
         isEnum = False
-#        isEnum = field.pbtype in ('ENUM', 'UENUM')
         var_name = StyleC.var_name(field.name)
         type_name = field.fieldType
-        if type_name in ts_types:
-            type_name = ts_types[type_name]
-        else:
-            type_name = '%s_%s' % (packageName, StyleC.struct_name(type_name))
 
-        if isEnum:
-            result += '    .UInt8(\'%s\', typed<%s>())' % (var_name, type_name)
+        # Handle arrays
+        if field.is_array:
+            if field.fieldType == "string":
+                if field.size_option is not None:  # Fixed size array [size=X]
+                    # Fixed string array: string[size] -> Array<string> with fixed length
+                    result += f'    // Fixed string array: {field.size_option} strings, each exactly {field.element_size} chars\n'
+                    result += f'    .Array(\'{var_name}\', \'String\', {field.size_option})'
+                else:  # Variable size array [max_size=X]
+                    # Variable string array: string[max_size=X, element_size=Y] -> Array<string> with count
+                    result += f'    // Variable string array: up to {field.max_size} strings, each max {field.element_size} chars\n'
+                    result += f'    .UInt8(\'{var_name}_count\')\n'
+                    result += f'    .Array(\'{var_name}_data\', \'String\', {field.max_size})'
+            else:
+                # Regular type arrays
+                if type_name in ts_types:
+                    base_type = ts_types[type_name]
+                else:
+                    base_type = f'{packageName.lower()}_{StyleC.struct_name(type_name).lower()}'
+
+                if field.size_option is not None:  # Fixed size array [size=X]
+                    # Fixed array: type[size] -> Array<type> with fixed length
+                    # For fixed arrays, size_option contains the exact size
+                    array_size = field.size_option
+                    result += f'    // Fixed array: always {array_size} elements\n'
+                    result += f'    .Array(\'{var_name}\', \'{base_type}\', {array_size})'
+                else:  # Variable size array [max_size=X]
+                    # Variable array: type[max_size=X] -> count + Array<type>
+                    max_count = field.max_size  # For variable arrays, max_size is the maximum count
+                    result += f'    // Variable array: up to {max_count} elements\n'
+                    result += f'    .UInt8(\'{var_name}_count\')\n'
+                    result += f'    .Array(\'{var_name}_data\', \'{base_type}\', {max_count})'
         else:
-            result += '    .%s(\'%s\')' % (type_name, var_name)
+            # Non-array fields (existing logic)
+            if field.fieldType == "string":
+                if hasattr(field, 'size_option') and field.size_option is not None:
+                    # Fixed string: string[size] -> fixed length string
+                    result += f'    // Fixed string: exactly {field.size_option} chars\n'
+                    result += f'    .String(\'{var_name}\', {field.size_option})'
+                elif hasattr(field, 'max_size') and field.max_size is not None:
+                    # Variable string: string[max_size=X] -> length + data
+                    result += f'    // Variable string: up to {field.max_size} chars\n'
+                    result += f'    .UInt8(\'{var_name}_length\')\n'
+                    result += f'    .String(\'{var_name}_data\', {field.max_size})'
+                else:
+                    # Default string handling (should not occur with new parser)
+                    result += f'    .String(\'{var_name}\')'
+            else:
+                # Regular types
+                if type_name in ts_types:
+                    type_name = ts_types[type_name]
+                else:
+                    type_name = f'{packageName}_{StyleC.struct_name(type_name)}'
+
+                if isEnum:
+                    result += f'    .UInt8(\'{var_name}\', typed<{type_name}>())'
+                else:
+                    result += f'    .{type_name}(\'{var_name}\')'
 
         leading_comment = field.comments
         if leading_comment:
@@ -182,11 +247,14 @@ class FileTsGen():
             yield '\n'
 
         if package.messages:
-            yield 'export function get_message_length(msg_id : number){\n switch (msg_id)\n {\n'
-            for key, msg in package.sortedMessages().items():
-
-                package_msg_name = '%s_%s' % (package.name, msg.name)
-                yield '  case %s_msgid: return %s_max_size;\n' % (package_msg_name, package_msg_name)
-
-            yield '  default: break;\n } return 0;\n}'
+            # Only generate get_message_length if there are messages with IDs
+            messages_with_id = [
+                msg for key, msg in package.sortedMessages().items() if msg.id]
+            if messages_with_id:
+                yield 'export function get_message_length(msg_id : number){\n switch (msg_id)\n {\n'
+                for msg in messages_with_id:
+                    package_msg_name = '%s_%s' % (package.name, msg.name)
+                    yield '  case %s_msgid: return %s_max_size;\n' % (package_msg_name, package_msg_name)
+
+                yield '  default: break;\n } return 0;\n}'
             yield '\n'

struct_frame-0.0.28.dist-info/METADATA

@@ -0,0 +1,311 @@
+Metadata-Version: 2.4
+Name: struct-frame
+Version: 0.0.28
+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
+Author-email: Rijesh Augustine <rijesh@mylonics.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: proto-schema-parser>=1.4.5
+Requires-Dist: structured-classes>=3.1.0
+Description-Content-Type: text/markdown
+
+
+# Struct Frame
+
+A multi-language code generation framework that converts Protocol Buffer (.proto) files into serialization/deserialization code for C, TypeScript, Python, and GraphQL. It provides framing and parsing utilities for structured message communication.
+
+## Quick Start
+
+### Installation
+```bash
+# Install Python dependencies
+pip install proto-schema-parser structured-classes
+
+# Install Node.js dependencies (for TypeScript)
+npm install
+```
+
+### Basic Usage
+```bash
+# Generate code for all languages
+PYTHONPATH=src python3 src/main.py examples/myl_vehicle.proto --build_c --build_ts --build_py --build_gql
+
+# Run comprehensive test suite
+python test_all.py
+
+# Generated files will be in the generated/ directory
+```
+
+### Test Suite
+
+The project includes a comprehensive test suite that validates code generation, compilation, and serialization across all supported languages:
+
+```bash
+# Run all tests
+python test_all.py
+
+# Run with verbose output
+python tests/run_tests.py --verbose
+
+# Skip specific languages
+python tests/run_tests.py --skip-ts --skip-c
+
+# Generate code only (no compilation/execution)
+python tests/run_tests.py --generate-only
+```
+
+See `tests/README.md` for detailed test documentation.
+
+### Language-Specific Examples
+
+#### Python
+```bash
+python src/main.py examples/myl_vehicle.proto --build_py
+# Use generated Python classes directly
+```
+
+#### TypeScript
+```bash
+python src/main.py examples/myl_vehicle.proto --build_ts
+npx tsc examples/index.ts --outDir generated/
+node generated/examples/index.js
+```
+
+#### C
+```bash
+python src/main.py examples/myl_vehicle.proto --build_c
+gcc examples/main.c -I generated/c -o main
+./main
+```
+
+#### GraphQL
+```bash
+python src/main.py examples/myl_vehicle.proto --build_gql
+# Use generated .graphql schema files
+```
+
+## Feature Compatibility Matrix
+
+| Feature | C | TypeScript | Python | GraphQL | Status |
+|---------|---|------------|--------|---------|--------|
+| **Core Types** | ✓ | ✓ | ✓ | ✓ | Stable |
+| **String** | ✓ | ✓ | ✓ | ✓ | Stable |
+| **Enums** | ✓ | ✓ | ✓ | ✓ | Stable |
+| **Nested Messages** | ✓ | ✓ | ✓ | ✓ | Stable |
+| **Message IDs** | ✓ | ✓ | ✓ | N/A | Stable |
+| **Message Serialization** | ✓ | ✓ | ✓ | N/A | Stable |
+| **Flatten** | N/A | N/A | ✓ | ✓ | Partial |
+| **Arrays** | ✓ | ✓ | ✓ | ✓ | Stable |
+
+**Legend:**
+- **✓** - Feature works as documented
+- **Partial** - Basic functionality works, some limitations  
+- **✗** - Feature not yet available
+- **N/A** - Not applicable for this language
+
+## Project Structure
+
+- `src/struct_frame/` - Core code generation framework
+  - `generate.py` - Main parser and validation logic
+  - `*_gen.py` - Language-specific code generators
+  - `boilerplate/` - Runtime libraries for each language
+- `examples/` - Example .proto files and usage demos
+  - `main.c` - C API demonstration (encoding/decoding, parsing)
+  - `index.ts` - TypeScript API demonstration (similar functionality)  
+  - `*.proto` - Protocol Buffer definitions for examples
+- `generated/` - Output directory for generated code (git-ignored)
+
+## Protocol Buffer Schema Reference
+
+### Supported Data Types
+
+| Type | Size (bytes) | Description | Range/Notes |
+|------|--------------|-------------|-------------|
+| **Integers** |
+| `int8` | 1 | Signed 8-bit integer | -128 to 127 |
+| `uint8` | 1 | Unsigned 8-bit integer | 0 to 255 |
+| `int16` | 2 | Signed 16-bit integer | -32,768 to 32,767 |
+| `uint16` | 2 | Unsigned 16-bit integer | 0 to 65,535 |
+| `int32` | 4 | Signed 32-bit integer | -2.1B to 2.1B |
+| `uint32` | 4 | Unsigned 32-bit integer | 0 to 4.3B |
+| `int64` | 8 | Signed 64-bit integer | Large integers |
+| `uint64` | 8 | Unsigned 64-bit integer | Large positive integers |
+| **Floating Point** |
+| `float` | 4 | Single precision (IEEE 754) | 7 decimal digits |
+| `double` | 8 | Double precision (IEEE 754) | 15-17 decimal digits |
+| **Other** |
+| `bool` | 1 | Boolean value | `true` or `false` |
+| `string` | Variable | UTF-8 encoded string | Length-prefixed |
+| `EnumType` | 1 | Custom enumeration | Defined in .proto |
+| `MessageType` | Variable | Nested message | User-defined structure |
+
+> **Note:** All types use little-endian byte order for cross-platform compatibility.
+
+### Array Support
+
+Arrays (repeated fields) support all data types - primitives, enums, and messages across all target languages.
+
+| Array Type | Syntax | Memory Usage | Use Case |
+|------------|--------|--------------|----------|
+| **Fixed** | `repeated type field = N [size=X];` | `sizeof(type) * X` | Matrices, buffers (always full) |  
+| **Bounded** | `repeated type field = N [max_size=X];` | 1 byte (count) + `sizeof(type) * X` | Dynamic lists with limits |
+| **String Arrays** | `repeated string field = N [max_size=X, element_size=Y];` | 1 byte (count) + `X * Y` bytes | Text collections with size limits |
+
+```proto
+message ArrayExample {
+  repeated float matrix = 1 [size=9];                        // 3x3 matrix (always 9 elements)
+  repeated string names = 2 [max_size=10, element_size=32];  // Up to 10 strings, each max 32 chars
+  repeated int32 values = 3 [max_size=100];                  // Up to 100 integers (variable count)
+}
+```
+
+**Generated Output** (all languages now supported):
+- **Python**: `matrix: list[float]`, `names: list[str]`, `values: list[int]`
+- **C**: `float matrix[9]`, `struct { uint8_t count; char data[10][32]; } names`
+- **TypeScript**: `Array('matrix', 'Float32LE', 9)`, `Array('names_data', 'String', 10)`  
+- **GraphQL**: `matrix: [Float!]!`, `names: [String!]!`, `values: [Int!]!`
+
+> **Important**: String arrays require both `max_size` (or `size`) AND `element_size` parameters because they are "arrays of arrays" - you need to specify both how many strings AND the maximum size of each individual string. This ensures predictable memory layout and prevents buffer overflows.
+
+### String Type
+
+Strings are a special case of bounded character arrays with built-in UTF-8 encoding and null-termination handling across all target languages.
+
+| String Type | Syntax | Memory Usage | Use Case |
+|-------------|--------|--------------|----------|
+| **Fixed String** | `string field = N [size=X];` | `X` bytes | Fixed-width text fields |
+| **Variable String** | `string field = N [max_size=X];` | 1 byte (length) + `X` bytes | Text with known maximum length |
+
+```proto
+message StringExample {
+  string device_name = 1 [size=16];              // Exactly 16 characters (pad with nulls)
+  string description = 2 [max_size=256];         // Up to 256 characters (length-prefixed)
+  string error_msg = 3 [max_size=128];           // Up to 128 characters for error messages
+}
+```
+
+**String Benefits:**
+- **Simplified Schema**: No need to specify `repeated uint8` for text data
+- **Automatic Encoding**: UTF-8 encoding/decoding handled by generators  
+- **Null Handling**: Proper null-termination and padding for fixed strings
+- **Type Safety**: Clear distinction between binary data and text
+- **Cross-Language**: Consistent string handling across C, TypeScript, and Python
+
+### Message Options
+
+**Message ID (`msgid`)** - Required for serializable messages:
+```proto
+message MyMessage {
+  option msgid = 42;  // Must be unique within package (0-65535)
+  string content = 1;
+}
+```
+
+### Field Options
+
+**Flatten (`flatten=true`)** - Merge nested message fields into parent:
+```proto
+message Position {
+  double lat = 1;
+  double lon = 2;
+}
+
+message Status {
+  Position pos = 1 [flatten=true];  // lat, lon become direct fields  
+  float battery = 2;
+}
+```
+
+**Array Options** - Control array behavior:
+```proto
+message Data {
+  repeated int32 fixed_buffer = 1 [size=256];                       // Always 256 integers  
+  repeated int32 var_buffer = 2 [max_size=256];                     // Up to 256 integers
+  repeated string messages = 3 [max_size=10, element_size=64];      // Up to 10 strings, each max 64 chars
+  string device_name = 4 [size=32];                                 // Always 32 characters
+  string description = 5 [max_size=256];                            // Up to 256 characters
+}
+```
+
+## Complete Example
+
+```proto
+package sensor_system;
+
+enum SensorType {
+  TEMPERATURE = 0;
+  HUMIDITY = 1;
+  PRESSURE = 2;
+}
+
+message Position {
+  double lat = 1;
+  double lon = 2;
+  float alt = 3;
+}
+
+message SensorReading {
+  option msgid = 1;
+  
+  uint32 device_id = 1;
+  int64 timestamp = 2;
+  SensorType type = 3;
+  
+  // Device name (fixed 16-character string)  
+  string device_name = 4 [size=16];
+  
+  // Sensor location (flattened)
+  Position location = 5 [flatten=true];
+  
+  // Measurement values (up to 8 readings)
+  repeated float values = 6 [max_size=8];
+  
+  // Calibration matrix (always 3x3 = 9 elements)
+  repeated float calibration = 7 [size=9];
+  
+  // Error message (up to 128 characters)
+  string error_msg = 8 [max_size=128];
+  
+  bool valid = 9;
+}
+
+message DeviceStatus {
+  option msgid = 2;
+  
+  uint32 device_id = 1;
+  repeated SensorReading recent_readings = 2 [max_size=10];
+  float battery_level = 3;
+}
+```
+
+## Schema Validation Rules
+
+- **Message IDs**: Must be unique within package (0-65535)
+- **Field numbers**: Must be unique within message  
+- **Array requirements**: All `repeated` fields must specify `[size=X]` (fixed) or `[max_size=X]` (bounded)
+- **String requirements**: All `string` fields must specify `[size=X]` (fixed) or `[max_size=X]` (variable)
+- **String array requirements**: `repeated string` fields must specify both array size AND `[element_size=Y]`
+- **Flatten constraints**: No field name collisions after flattening
+- **Size limits**: Arrays limited to 255 elements maximum
+
+## Code Generation
+
+```bash
+# Generate all languages
+python src/main.py schema.proto --build_c --build_ts --build_py --build_gql
+
+# Language-specific paths
+python src/main.py schema.proto --build_py --py_path output/python/
+python src/main.py schema.proto --build_c --c_path output/c/
+python src/main.py schema.proto --build_ts --ts_path output/typescript/
+python src/main.py schema.proto --build_gql --gql_path output/graphql/
+```
+
+## Additional Documentation
+
+- **[Array Implementation Guide](ARRAY_IMPLEMENTATION.md)** - Comprehensive documentation of array features, syntax, and generated code examples across all languages

struct_frame-0.0.28.dist-info/RECORD

@@ -0,0 +1,12 @@
+struct_frame/__init__.py,sha256=m9hfIbcgCYvt-fIeYrJRQyk6I7rq35jSdZIhrMmZntg,374
+struct_frame/__main__.py,sha256=tIybnBeFHvwiwVhodVOSnxhne5AX_80mtXBx4rneSB4,143
+struct_frame/base.py,sha256=1Z_0vMkwz0X8r2hIVLv5yuhwwD929LwNMzVKBqFxxac,2012
+struct_frame/c_gen.py,sha256=I-VFeVmOBlvjZuRehljEjRxJComWGIwOsNe1ex77RLI,9555
+struct_frame/generate.py,sha256=8YL4MJ--vvOsv5MFqGjKSATSulanEqX_Qf0Jew6x7UU,23416
+struct_frame/gql_gen.py,sha256=jDLsyZJmfpVBpdXE06mixZ3D01NAmRioGJqk_FoQt90,7543
+struct_frame/py_gen.py,sha256=EQqw8u2o-FszROviQyQCpF45bbx0KqjdqVBefpyDqH4,7932
+struct_frame/ts_gen.py,sha256=glT9eA--j_8vaR8tHQ0ekDg7udIVgE9FGA4MGAwiCsA,10103
+struct_frame-0.0.28.dist-info/METADATA,sha256=30k3JtXITayQdbY9UmOxcHTriwp3A9k7rX_EirMMXGU,10831
+struct_frame-0.0.28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+struct_frame-0.0.28.dist-info/licenses/LICENSE,sha256=UjbLtGfcHCIqJg9UzEVGoNW8fyX4Ah9ZbsuAmJ_vhmk,1094
+struct_frame-0.0.28.dist-info/RECORD,,

struct_frame/boilerplate/c/struct_frame.h

@@ -1,103 +0,0 @@
-#pragma once
-#include "stdbool.h"
-#include "stdint.h"
-#include "string.h"
-#include "struct_frame_types.h"
-
-static inline struct checksum_t fletcher_checksum_calculation(uint8_t *buffer, uint8_t data_length) {
-  checksum_t checksum;
-
-  for (int i = 0; i < data_length; i++) {
-    checksum.byte1 += buffer[i];
-    checksum.byte2 += checksum.byte1;
-  }
-  return checksum;
-}
-
-static inline bool msg_encode(struct_buffer *buffer, void *msg_buffer, uint8_t msg_id, uint8_t size) {
-  if (buffer->in_progress) {
-    return false;
-  }
-  buffer->in_progress = true;
-
-  buffer->data[buffer->size++] = buffer->config.start_byte;
-  buffer->crc_start_loc = buffer->size;
-  buffer->data[buffer->size++] = msg_id;
-
-  if (buffer->config.has_len) {
-    buffer->data[buffer->size++] = size;
-  }
-  memcpy(buffer->data + buffer->size, (uint8_t *)msg_buffer, size);
-  buffer->size += size;
-  if (buffer->config.has_crc) {
-    checksum_t crc =
-        fletcher_checksum_calculation(buffer->data + buffer->crc_start_loc, buffer->crc_start_loc - buffer->size);
-    buffer->data[buffer->size++] = crc.byte1;
-    buffer->data[buffer->size++] = crc.byte2;
-  }
-  buffer->in_progress = false;
-  return true;
-}
-
-static inline void *msg_reserve(struct_buffer *buffer, uint8_t msg_id, uint8_t size) {
-  if (buffer->in_progress) {
-    return 0;
-  }
-  buffer->in_progress = true;
-  buffer->data[buffer->size++] = buffer->config.start_byte;
-
-  buffer->data[buffer->size++] = msg_id;
-  if (buffer->config.has_len) {
-    buffer->data[buffer->size++] = size;
-  }
-
-  void *out = &buffer->data[buffer->size];
-  buffer->size += size;
-
-  return out;
-}
-
-static inline bool msg_finish(struct_buffer *buffer) {
-  if (buffer->in_progress == false) {
-    return false;
-  }
-  if (buffer->config.has_crc) {
-    checksum_t crc =
-        fletcher_checksum_calculation(buffer->data + buffer->crc_start_loc, buffer->crc_start_loc - buffer->size);
-    buffer->data[buffer->size++] = crc.byte1;
-    buffer->data[buffer->size++] = crc.byte2;
-  }
-  buffer->in_progress = false;
-  return true;
-}
-
-#define MESSAGE_HELPER(funcname, name, msg_size, msg_id)                                           \
-  static inline bool funcname##_encode(struct_buffer *buffer, name *name##_obj) {                  \
-    return msg_encode(buffer, name##_obj, msg_id, msg_size);                                       \
-  }                                                                                                \
-  static inline bool funcname##_reserve(struct_buffer *buffer, name **msg) {                       \
-    void *ptr = msg_reserve(buffer, msg_id, msg_size);                                             \
-    if (ptr) {                                                                                     \
-      *msg = (name *)ptr;                                                                          \
-      return true;                                                                                 \
-    }                                                                                              \
-    return false;                                                                                  \
-  }                                                                                                \
-  static inline bool funcname##_finish(struct_buffer *buffer) { return msg_finish(buffer); }       \
-  static inline name funcname##_get(struct_buffer *buffer) {                                       \
-    name msg = *(name *)(buffer->data);                                                            \
-    return msg;                                                                                    \
-  }                                                                                                \
-  static inline name funcname##_get(uint8_t *buffer) {                                             \
-    name msg = *(name *)(buffer);                                                                  \
-    return msg;                                                                                    \
-  }                                                                                                \
-  static inline name funcname##_get_from_buffer_result(buffer_parser_result_t result) {            \
-    name msg = *(name *)(result.msg_loc);                                                          \
-    return msg;                                                                                    \
-  }                                                                                                \
-  static inline name *funcname##_get_ref(struct_buffer *buffer) { return (name *)(buffer->data); } \
-  static inline name *funcname##_get_ref(uint8_t *buffer) { return (name *)(buffer); }             \
-  static inline name *funcname##_get_ref_from_buffer_result(buffer_parser_result_t result) {       \
-    return (name *)(result.msg_loc);                                                               \
-  }