Struct QueueStreamed 

pub struct QueueStreamed<T: StructSerde>(/* private fields */);

A type-safe FIFO queue for message passing.

Unlike Queue, which works with raw byte slices, QueueStreamed provides a type-safe interface for sending and receiving structured data. The type must implement serialization traits.

Type Parameters

• T - The message type. Must implement ToBytes, BytesHasLen, and FromBytes

Examples

Basic typed queue usage

use osal_rs::os::{QueueStreamed, QueueStreamedFn};
use core::time::Duration;
 
#[derive(Debug, Clone, Copy)]
struct Message {
    id: u32,
    value: i16,
}
 
// Assuming Message implements the required traits
let queue: QueueStreamed<Message> = QueueStreamed::new(10, size_of::<Message>()).unwrap();
 
// Send a message
let msg = Message { id: 1, value: 42 };
queue.post_with_to_tick(&msg, Duration::from_millis(100)).unwrap();
 
// Receive a message
let mut received = Message { id: 0, value: 0 };
queue.fetch_with_to_tick(&mut received, Duration::from_millis(100)).unwrap();
assert_eq!(received.id, 1);
assert_eq!(received.value, 42);

Command queue pattern

use osal_rs::os::{QueueStreamed, Thread};
use alloc::sync::Arc;
 
enum Command {
    Start,
    Stop,
    SetValue(u32),
}
 
let cmd_queue = Arc::new(QueueStreamed::<Command>::new(10, 8).unwrap());
let queue_clone = cmd_queue.clone();
 
let handler = Thread::new("handler", 2048, 5, move || {
    loop {
        let mut cmd = Command::Stop;
        if queue_clone.fetch(&mut cmd, 1000).is_ok() {
            match cmd {
                Command::Start => { /* start operation */ },
                Command::Stop => { /* stop operation */ },
                Command::SetValue(val) => { /* set value */ },
            }
        }
    }
}).unwrap();

Implementations

impl<T> QueueStreamed<T>

where T: StructSerde,

pub fn new(size: UBaseType, message_size: UBaseType) -> Result<Self>

Creates a new type-safe queue.

Parameters

• size - Maximum number of messages
• message_size - Size of each message (typically size_of::<T>())

Returns

• Ok(Self) - Successfully created queue
• Err(Error) - Creation failed

Trait Implementations

impl<T> Debug for QueueStreamed<T>

where T: StructSerde,

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

Formats the value using the given formatter.

impl<T> Deref for QueueStreamed<T>

where T: StructSerde,

type Target = *const c_void

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> Display for QueueStreamed<T>

where T: StructSerde,

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

Formats the value using the given formatter.

impl<T> QueueStreamed<T> for QueueStreamed<T>

where T: StructSerde,

Available on non-crate feature serde only.

fn fetch(&self, buffer: &mut T, time: TickType) -> Result<()>

Fetches a typed message from the queue (blocking).

fn fetch_from_isr(&self, buffer: &mut T) -> Result<()>

Fetches a typed message from ISR context (non-blocking).

fn post(&self, item: &T, time: TickType) -> Result<()>

Posts a typed message to the queue (blocking).

fn post_from_isr(&self, item: &T) -> Result<()>

Posts a typed message from ISR context (non-blocking).

fn delete(&mut self)

Deletes the queue and frees its resources.

impl<T: StructSerde> Send for QueueStreamed<T>

impl<T: StructSerde> Sync for QueueStreamed<T>