Struct lc3_ensemble::sim::io::BlockingQueue

pub struct BlockingQueue<T> { /* private fields */ }

A simple multi-producer, multi-consumer blocking queue.

This queue allows producers and consumers to respectively send and receive data from the provided buffer.

A blocking queue can be paired with BiChannelIO to maintain an input buffer:

use lc3_ensemble::sim::io::{BiChannelIO, BlockingQueue, Stop};
 
let queue = BlockingQueue::new(None);
 
// fn writer(_: u8) -> Result<(), Stop> { ... }
// let mcr = ...
 
let io = BiChannelIO::new(queue.reader(), writer, mcr);

Implementations

impl<T> BlockingQueue<T>

pub fn new(size: Option<usize>) -> Self

Creates a new blocking queue, optionally with a maximum size.

pub fn push(&self, t: T)

Adds an element to the front of the queue, blocking if the queue is full.

pub fn try_push(&self, t: T) -> Result<(), TrySendError<T>>

Adds an element to the front of the queue, returning an error if the queue is full.

This uses crossbeam_channel::TrySendError as its error, but this function cannot return TrySendError::Disconnected, since the BlockingQueue has to exist to call this function.

pub fn pop(&self) -> T

Removes an element from the back of the queue, blocking if the queue is full.

pub fn try_pop(&self) -> Result<T, TryRecvError>

Removes an element from the back of the queue, returning an error if the queue is full.

This uses crossbeam_channel::TryRecvError as its error, but this function cannot return TryRecvError::Disconnected, since the BlockingQueue has to exist to call this function.

pub fn head(&self) -> Sender<T>

Exposes the sending head of the queue.

This enables all methods of crossbeam_channel::Sender to be used. However, because the sender’s lifetime is not dependent on the queue’s lifetime, users of this function should verify that the sender is not disconnected when calling Sender::send and similar functions.

pub fn tail(&self) -> Receiver<T>

Exposes the receiving tail of the queue.

This enables all methods of crossbeam_channel::Receiver to be used. However, because the receiver’s lifetime is not dependent on the queue’s lifetime, users of this function should verify that the sender is not disconnected when calling Receiver::recv and similar functions.

pub fn len(&self) -> usize

Returns the number of bytes currently in the channel.

pub fn is_empty(&self) -> bool

Returns whether there are any bytes in the channel (true if not).

pub fn reader(&self) -> impl Fn() -> Result<T, Stop>

A utility to allow this queue to interop with BiChannelIO.

This can be used as the reader parameter of BiChannelIO::new to allow the IO device to poll this queue for data. See the struct-level documentation for an example.

Trait Implementations

impl<T> Default for BlockingQueue<T>

fn default() -> Self

Returns the “default value” for a type.

impl<E> Extend<E> for BlockingQueue<E>

fn extend<T: IntoIterator<Item = E>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.