Struct ByteSerializer 

pub struct ByteSerializer<'a> { /* private fields */ }

A serializer that writes data to a byte buffer in little-endian format.

This is a concrete implementation of the Serializer trait that writes binary data in a compact, little-endian format. This is the default serializer used by the crate::to_bytes convenience function.

Format

• All integers are written in little-endian byte order
• Floating-point numbers use IEEE 754 representation
• bool is written as a single byte (0 or 1)
• Option<T>: 1 byte tag (0=None, 1=Some) followed by T if Some
• Arrays: Elements serialized sequentially (no length prefix)
• Tuples: Elements serialized sequentially
• Strings/Vec: u32 length prefix followed by data

Examples

Basic Usage

use osal_rs_serde::{ByteSerializer, Serializer, Serialize};

let mut buffer = [0u8; 16];
let mut serializer = ByteSerializer::new(&mut buffer);

serializer.serialize_u32("", 42).unwrap();
serializer.serialize_bool("", true).unwrap();
serializer.serialize_i16("", -100).unwrap();

let len = serializer.position();
println!("Serialized {} bytes", len);

With Structs

use osal_rs_serde::{ByteSerializer, Serialize};

#[derive(Serialize)]
struct Message {
    id: u32,
    value: i16,
}

let msg = Message { id: 100, value: -50 };
let mut buffer = [0u8; 32];
let mut serializer = ByteSerializer::new(&mut buffer);
msg.serialize(&mut serializer).unwrap();

Memory Layout

The serializer writes data sequentially without padding or alignment:

struct Data { a: u16, b: u32 }
Memory: [a_lo, a_hi, b0, b1, b2, b3]

Implementations

impl<'a> ByteSerializer<'a>

pub fn new(buffer: &'a mut [u8]) -> Self

Create a new ByteSerializer with the given buffer.

pub fn position(&self) -> usize

Get the current position in the buffer.

Trait Implementations

impl<'a> Serializer for ByteSerializer<'a>

fn serialize_array<T>(&mut self, name: &str, v: &[T]) -> Result<(), Self::Error>

where T: Serialize,

Serialize an array of serializable items.

type Error = Error

The error type that can be returned during serialization.

fn serialize_bool(&mut self, _name: &str, v: bool) -> Result<()>

Serialize a bool value.

fn serialize_u8(&mut self, _name: &str, v: u8) -> Result<()>

Serialize a u8 value.

fn serialize_i8(&mut self, _name: &str, v: i8) -> Result<()>

Serialize an i8 value.

fn serialize_u16(&mut self, _name: &str, v: u16) -> Result<()>

Serialize a u16 value.

fn serialize_i16(&mut self, _name: &str, v: i16) -> Result<()>

Serialize an i16 value.

fn serialize_u32(&mut self, _name: &str, v: u32) -> Result<()>

Serialize a u32 value.

fn serialize_i32(&mut self, _name: &str, v: i32) -> Result<()>

Serialize an i32 value.

fn serialize_u64(&mut self, _name: &str, v: u64) -> Result<()>

Serialize a u64 value.

fn serialize_i64(&mut self, _name: &str, v: i64) -> Result<()>

Serialize an i64 value.

fn serialize_u128(&mut self, _name: &str, v: u128) -> Result<()>

Serialize a u128 value.

fn serialize_i128(&mut self, _name: &str, v: i128) -> Result<()>

Serialize an i128 value.

fn serialize_f32(&mut self, _name: &str, v: f32) -> Result<()>

Serialize an f32 value.

fn serialize_f64(&mut self, _name: &str, v: f64) -> Result<()>

Serialize an f64 value.

fn serialize_bytes(&mut self, _name: &str, v: &[u8]) -> Result<()>

Serialize a byte slice.

fn serialize_string( &mut self, name: &str, v: &String, ) -> Result<(), Self::Error>

Serialize a string.

fn serialize_str(&mut self, name: &str, v: &str) -> Result<(), Self::Error>

Serialize a string slice.

fn serialize_vec<T>( &mut self, name: &str, v: &Vec<T>, ) -> Result<(), Self::Error>

where T: Serialize,

Serialize a vector of serializable items.

fn serialize_struct_start( &mut self, _name: &str, _len: usize, ) -> Result<(), Self::Error>

Begin serializing a struct with the given name and number of fields. Default implementation does nothing (suitable for binary formats).

fn serialize_field<T>( &mut self, name: &str, value: &T, ) -> Result<(), Self::Error>

where T: Serialize,

Serialize a struct field with name and value. Default implementation just serializes the value.

fn serialize_struct_end(&mut self) -> Result<(), Self::Error>

End serializing a struct. Default implementation does nothing (suitable for binary formats).