Struct Bytes 

pub struct Bytes<const SIZE: usize>(pub [u8; SIZE]);

Tuple Fields

0: [u8; SIZE]

Implementations

impl<const SIZE: usize> Bytes<SIZE>

pub const fn new() -> Self

Creates a new Bytes instance filled with zeros.

This is a const function, allowing it to be used in const contexts and static variable declarations.

Returns

A Bytes instance with all bytes set to 0.

Examples

use osal_rs::utils::Bytes;
 
const BUFFER: Bytes<64> = Bytes::new();
 
let runtime_buffer = Bytes::<32>::new();
assert_eq!(runtime_buffer[0], 0);

pub fn new_by_str(str: &str) -> Self

Creates a new Bytes instance from a string slice.

Copies the bytes from the input string into the fixed-size array. If the string is shorter than SIZE, the remaining bytes are zero-filled. If the string is longer, it is truncated to fit.

Parameters

• str - The source string to convert

Returns

A Bytes instance containing the string data.

Examples

use osal_rs::utils::Bytes;

let short = Bytes::<16>::new_by_str("Hi");
// Internal array: [b'H', b'i', 0, 0, 0, ...]

let exact = Bytes::<5>::new_by_str("Hello");
// Internal array: [b'H', b'e', b'l', b'l', b'o']

let long = Bytes::<3>::new_by_str("Hello");
// Internal array: [b'H', b'e', b'l'] (truncated)

pub fn new_by_ptr(str: *const c_char) -> Self

Creates a new Bytes instance from a C string pointer.

Safely converts a null-terminated C string pointer into a Bytes instance. If the pointer is null, returns a zero-initialized Bytes. The function copies bytes from the C string into the fixed-size array, truncating if the source is longer than SIZE.

Parameters

• str - A pointer to a null-terminated C string (*const c_char)

Safety

While this function is not marked unsafe, it internally uses unsafe code to dereference the pointer. The caller must ensure that:

• If not null, the pointer points to a valid null-terminated C string
• The memory the pointer references remains valid for the duration of the call

Returns

A Bytes instance containing the C string data, or zero-initialized if the pointer is null.

Examples

use osal_rs::utils::Bytes;
use core::ffi::c_char;
use alloc::ffi::CString;

// From a CString
let c_string = CString::new("Hello").unwrap();
let bytes = Bytes::<16>::new_by_ptr(c_string.as_ptr());

// From a null pointer
let null_bytes = Bytes::<16>::new_by_ptr(core::ptr::null());
// Returns zero-initialized Bytes

// Truncation example
let long_string = CString::new("This is a very long string").unwrap();
let short_bytes = Bytes::<8>::new_by_ptr(long_string.as_ptr());
// Only first 8 bytes are copied

pub fn new_by_as_sync_str(str: &impl ToString) -> Self

Creates a new Bytes instance from any type implementing ToString.

This is a convenience wrapper around new_by_str that first converts the input to a string.

Parameters

• str - Any value that implements ToString

Returns

A Bytes instance containing the string representation of the input.

Examples

use osal_rs::utils::Bytes;

// From integer
let num_bytes = Bytes::<8>::new_by_string(&42);

// From String
let string = String::from("Task");
let str_bytes = Bytes::<16>::new_by_string(&string);

// From custom type with ToString
#[derive(Debug)]
struct TaskId(u32);
impl ToString for TaskId {
    fn to_string(&self) -> String {
        format!("Task-{}", self.0)
    }
}
let task_bytes = Bytes::<16>::new_by_string(&TaskId(5));

pub fn new_by_bytes(bytes: &[u8]) -> Self

pub fn fill_str(&mut self, dest: &mut str) -> Result<()>

Fills a mutable string slice with the contents of the byte array.

Attempts to convert the internal byte array to a UTF-8 string and copies it into the destination string slice. Only copies up to the minimum of the source and destination lengths.

Parameters

• dest - The destination string slice to fill

Returns

Ok(()) if the operation succeeds, or Err(Error::StringConversionError) if the byte array cannot be converted to a valid UTF-8 string.

Examples

use osal_rs::utils::Bytes;
 
let bytes = Bytes::<16>::new_by_str("Hello World");
 
let mut output = String::from("                "); // 16 spaces
bytes.fill_str(unsafe { output.as_mut_str() });
 
assert_eq!(&output[..11], "Hello World");

pub fn as_c_str(&self) -> &CStr

Converts the byte array to a C string reference.

Creates a CStr reference from the internal byte array, treating it as a null-terminated C string. This is useful for passing strings to C FFI functions that expect *const c_char or &CStr.

Safety

This method is unsafe because it assumes:

• The byte array contains valid UTF-8 data
• The byte array is null-terminated
• There are no interior null bytes before the terminating null

Violating these assumptions may lead to undefined behavior.

Returns

A reference to a CStr with lifetime tied to self.

Examples

use osal_rs::utils::Bytes;
 
let bytes = Bytes::<16>::new_by_str("Hello");
let c_str = bytes.as_c_str();
 
extern "C" {
    fn print_string(s: *const core::ffi::c_char);
}
 
unsafe {
    print_string(c_str.as_ptr());
}

pub fn as_cstring(&self) -> CString

Converts the byte array to an owned C string.

Creates a new CString by copying the contents of the internal byte array. Unlike as_c_str, this method allocates heap memory and returns an owned string that can outlive the original Bytes instance.

Safety

This method uses from_vec_unchecked which assumes the byte array does not contain any interior null bytes. If this assumption is violated, the resulting CString will be invalid.

Returns

An owned CString containing a copy of the byte array data.

Memory Allocation

This method allocates on the heap. In memory-constrained embedded systems, prefer as_c_str when possible.

Examples

use osal_rs::utils::Bytes;
 
fn process_name(bytes: &Bytes<16>) -> alloc::ffi::CString {
    // Create an owned copy that can be returned
    bytes.as_cstring()
}
 
let name = Bytes::<16>::new_by_str("Task");
let owned = process_name(&name);
// 'name' can be dropped, 'owned' still valid

pub fn append_str(&mut self, str: &str)

Appends a string slice to the existing content in the Bytes buffer.

This method finds the current end of the content (first null byte) and appends the provided string starting from that position. If the buffer is already full or if the appended content would exceed the buffer size, the content is truncated to fit within the SIZE limit.

Parameters

• str - The string slice to append

Examples

use osal_rs::utils::Bytes;

let mut bytes = Bytes::<16>::new_by_str("Hello");
bytes.append_str(" World");
assert_eq!(bytes.as_str(), "Hello World");

// Truncation when exceeding buffer size
let mut small_bytes = Bytes::<8>::new_by_str("Hi");
small_bytes.append_str(" there friend");
assert_eq!(small_bytes.as_str(), "Hi ther");

pub fn append_as_sync_str(&mut self, c_str: &impl AsSyncStr)

Appends content from any type implementing AsSyncStr to the buffer.

This method accepts any type that implements the AsSyncStr trait, converts it to a string slice, and appends it to the existing content. If the buffer is already full or if the appended content would exceed the buffer size, the content is truncated to fit within the SIZE limit.

Parameters

• c_str - A reference to any type implementing AsSyncStr

Examples

use osal_rs::utils::Bytes;

let mut bytes = Bytes::<16>::new_by_str("Hello");
let other_bytes = Bytes::<8>::new_by_str(" World");
bytes.append_as_sync_str(&other_bytes);
assert_eq!(bytes.as_str(), "Hello World");

pub fn append_bytes(&mut self, bytes: &[u8])

Appends raw bytes to the existing content in the Bytes buffer.

This method finds the current end of the content (first null byte) and appends the provided byte slice starting from that position. If the buffer is already full or if the appended content would exceed the buffer size, the content is truncated to fit within the SIZE limit.

Parameters

• bytes - The byte slice to append

Examples

use osal_rs::utils::Bytes;

let mut bytes = Bytes::<16>::new_by_str("Hello");
bytes.append_bytes(b" World");
assert_eq!(bytes.as_str(), "Hello World");

// Appending arbitrary bytes
let mut data = Bytes::<16>::new_by_str("Data: ");
data.append_bytes(&[0x41, 0x42, 0x43]);
assert_eq!(data.as_str(), "Data: ABC");

pub fn append<const OHTER_SIZE: usize>(&mut self, other: &Bytes<OHTER_SIZE>)

Appends the content of another Bytes instance to this buffer.

This method allows appending content from a Bytes instance of a different size (specified by the generic parameter OHTER_SIZE). The method finds the current end of the content (first null byte) and appends the content from the other Bytes instance. If the buffer is already full or if the appended content would exceed the buffer size, the content is truncated to fit within the SIZE limit.

Type Parameters

• OHTER_SIZE - The size of the source Bytes buffer (can be different from SIZE)

Parameters

• other - A reference to the Bytes instance to append

Examples

use osal_rs::utils::Bytes;

let mut bytes = Bytes::<16>::new_by_str("Hello");
let other = Bytes::<8>::new_by_str(" World");
bytes.append(&other);
assert_eq!(bytes.as_str(), "Hello World");

// Appending from a larger buffer
let mut small = Bytes::<8>::new_by_str("Hi");
let large = Bytes::<32>::new_by_str(" there friend");
small.append(&large);
assert_eq!(small.as_str(), "Hi ther");

pub fn clear(&mut self)

Clears all content from the buffer, filling it with zeros.

This method resets the entire internal byte array to zeros, effectively clearing any stored data. After calling this method, the buffer will be empty and ready for new content.

Examples

use osal_rs::utils::Bytes;

let mut bytes = Bytes::<16>::new_by_str("Hello");
assert!(!bytes.is_empty());

bytes.clear();
assert!(bytes.is_empty());
assert_eq!(bytes.len(), 0);

pub fn len(&self) -> usize

Returns the length of the content in the buffer.

The length is determined by finding the position of the first null byte (0). If no null byte is found, returns SIZE, indicating the buffer is completely filled with non-zero data.

Returns

The number of bytes before the first null terminator, or SIZE if the buffer is completely filled.

Examples

use osal_rs::utils::Bytes;

let bytes = Bytes::<16>::new_by_str("Hello");
assert_eq!(bytes.len(), 5);

let empty = Bytes::<16>::new();
assert_eq!(empty.len(), 0);

// Buffer completely filled (no null terminator)
let mut full = Bytes::<4>::new();
full[0] = b'A';
full[1] = b'B';
full[2] = b'C';
full[3] = b'D';
assert_eq!(full.len(), 4);

pub fn is_empty(&self) -> bool

Checks if the buffer is empty.

A buffer is considered empty if all bytes are zero. This method searches for the first non-zero byte to determine emptiness.

Returns

true if all bytes are zero, false otherwise.

Examples

use osal_rs::utils::Bytes;

let empty = Bytes::<16>::new();
assert!(empty.is_empty());

let bytes = Bytes::<16>::new_by_str("Hello");
assert!(!bytes.is_empty());

let mut cleared = Bytes::<16>::new_by_str("Test");
cleared.clear();
assert!(cleared.is_empty());

pub fn capacity(&self) -> usize

Returns the total capacity of the buffer.

This is the fixed size of the internal byte array, determined at compile time by the generic SIZE parameter. The capacity never changes during the lifetime of the Bytes instance.

Returns

The total capacity in bytes (SIZE).

Examples

use osal_rs::utils::Bytes;

let bytes = Bytes::<32>::new();
assert_eq!(bytes.capacity(), 32);

let other = Bytes::<128>::new_by_str("Hello");
assert_eq!(other.capacity(), 128);

pub fn replace(&mut self, find: &[u8], replace: &[u8]) -> Result<()>

Replaces all occurrences of a byte pattern with another pattern.

This method searches for all occurrences of the find byte sequence within the buffer and replaces them with the replace byte sequence. The replacement is performed in a single pass, and the method handles cases where the replacement is larger, smaller, or equal in size to the pattern being searched for.

Parameters

• find - The byte pattern to search for
• replace - The byte pattern to replace with

Returns

• Ok(()) - If all replacements were successful
• Err(Error::StringConversionError) - If the replacement would exceed the buffer capacity

Behavior

• Empty find patterns are ignored (returns Ok(()) immediately)
• Multiple occurrences are replaced in a single pass
• Content is properly shifted when replacement size differs from find size
• Null terminators and trailing bytes are correctly maintained
• Overlapping patterns are not re-matched (avoids infinite loops)

Examples

use osal_rs::utils::Bytes;

// Same length replacement
let mut bytes = Bytes::<16>::new_by_str("Hello World");
bytes.replace(b"World", b"Rust!").unwrap();
assert_eq!(bytes.as_str(), "Hello Rust!");

// Shorter replacement
let mut bytes2 = Bytes::<16>::new_by_str("aabbcc");
bytes2.replace(b"bb", b"X").unwrap();
assert_eq!(bytes2.as_str(), "aaXcc");

// Longer replacement
let mut bytes3 = Bytes::<16>::new_by_str("Hi");
bytes3.replace(b"Hi", b"Hello").unwrap();
assert_eq!(bytes3.as_str(), "Hello");

// Multiple occurrences
let mut bytes4 = Bytes::<32>::new_by_str("foo bar foo");
bytes4.replace(b"foo", b"baz").unwrap();
assert_eq!(bytes4.as_str(), "baz bar baz");

// Buffer overflow error
let mut small = Bytes::<8>::new_by_str("Hello");
assert!(small.replace(b"Hello", b"Hello World").is_err());

pub fn to_bytes(&self) -> &[u8]

Converts the Bytes instance to a byte slice.

This method provides a convenient way to access the internal byte array as a slice, which can be useful for C FFI or other operations that require byte slices.

Examples

use osal_rs::utils::{Bytes, ToBytes};
 
let bytes = Bytes::<8>::new_by_str("example");
let byte_slice = bytes.to_bytes();
assert_eq!(byte_slice, b"example\0\0");

Trait Implementations

impl<const SIZE: usize> AsSyncStr for Bytes<SIZE>

fn as_str(&self) -> &str

Returns a string slice reference.

This method provides access to the underlying string data in a way that is safe to use across thread boundaries.

Returns

A reference to a string slice with lifetime tied to self.

impl<const SIZE: usize> Clone for Bytes<SIZE>

fn clone(&self) -> Bytes<SIZE>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const SIZE: usize> Debug for Bytes<SIZE>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const SIZE: usize> Deref for Bytes<SIZE>

fn deref(&self) -> &Self::Target

Dereferences to the underlying byte array.

This allows Bytes to be used anywhere a [u8; SIZE] reference is expected.

Examples

use osal_rs::utils::Bytes;
 
let bytes = Bytes::<8>::new_by_str("test");
assert_eq!(bytes[0], b't');

type Target = [u8; SIZE]

The resulting type after dereferencing.

impl<const SIZE: usize> DerefMut for Bytes<SIZE>

fn deref_mut(&mut self) -> &mut Self::Target

Provides mutable access to the underlying byte array.

This allows Bytes to be mutably dereferenced, enabling direct modification of the internal byte array through the DerefMut trait.

Examples

use osal_rs::utils::Bytes;
 
let mut bytes = Bytes::<8>::new();
bytes[0] = b'H';
bytes[1] = b'i';
assert_eq!(bytes[0], b'H');

impl<const SIZE: usize> Deserialize for Bytes<SIZE>

Available on non-crate feature serde only.

Deserialization implementation for Bytes<SIZE> when the serde feature is disabled.

This implementation provides basic deserialization by copying bytes from a slice into a fixed-size array. If the source slice is shorter than SIZE, the remaining bytes are zero-filled. If longer, it’s truncated to fit.

fn from_bytes(bytes: &[u8]) -> Result<Self>

Creates a Bytes instance from a byte slice.

Parameters

• bytes - The source byte slice to deserialize from

Returns

• Ok(Bytes<SIZE>) - A new Bytes instance with data copied from the slice

Examples

use osal_rs::utils::Bytes;
use osal_rs::os::Deserialize;
 
let data = b"Hello";
let bytes = Bytes::<16>::from_bytes(data).unwrap();
// Result: [b'H', b'e', b'l', b'l', b'o', 0, 0, 0, ...]

impl<const SIZE: usize> Display for Bytes<SIZE>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the byte array as a C-style null-terminated string.

This implementation treats the byte array as a C string and converts it to a Rust string for display. If the conversion fails, it displays “Conversion error”.

Safety

This method assumes the byte array contains valid UTF-8 data and is null-terminated. Invalid data may result in the error message being displayed.

Examples

use osal_rs::utils::Bytes;
 
let bytes = Bytes::<16>::new_by_str("Hello");
println!("{}", bytes); // Prints "Hello"

impl<const SIZE: usize> FromStr for Bytes<SIZE>

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<const SIZE: usize> Hash for Bytes<SIZE>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const SIZE: usize> Ord for Bytes<SIZE>

fn cmp(&self, other: &Bytes<SIZE>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const SIZE: usize> PartialEq for Bytes<SIZE>

fn eq(&self, other: &Bytes<SIZE>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SIZE: usize> PartialOrd for Bytes<SIZE>

fn partial_cmp(&self, other: &Bytes<SIZE>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const SIZE: usize> Serialize for Bytes<SIZE>

Available on non-crate feature serde only.

Serialization implementation for Bytes<SIZE> when the serde feature is disabled.

This implementation provides basic serialization by directly returning a reference to the underlying byte array. It’s used when the library is compiled without the serde feature, providing a lightweight alternative serialization mechanism.

fn to_bytes(&self) -> &[u8]

Converts the Bytes instance to a byte slice.

Returns

A reference to the internal byte array.

impl<const SIZE: usize> Copy for Bytes<SIZE>

impl<const SIZE: usize> Eq for Bytes<SIZE>

impl<const SIZE: usize> StructuralPartialEq for Bytes<SIZE>