Struct Channel 

pub struct Channel { /* private fields */ }

In-memory, asynchronous, many-to-many byte channel with explicit backpressure semantics.

Writers and readers operate on a shared ring buffer while maintaining their own monotonic cursors. Reserving slices (writers) or releasing read positions (readers) is the only way to advance those cursors, ensuring deterministic progress and preventing aliasing of the underlying buffer.

Implementations

impl Channel

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

Create a channel with the provided capacity in bytes.

pub fn with_parameters(size: usize, backpressure: Backpressure) -> Arc<Self>

Create a channel with the given parameters.

pub fn new_writer(self: &Arc<Channel>) -> Writer

Create a new writer to push bytes to the channel.

Concurrency

Writers can work somewhat concurrently, given enough buffer space. This works by allowing multiple writers to reserve and write contiguous buffer “slices”, provided that those slices do not overwrite any part of the buffer being consumed by a strong reader. Readers are not aware of slices and will read the buffer in the order that slices are written. If a writer hangs while writing a slice, no subsequent slices will be read.

pub fn new_strong_writer(self: &Arc<Channel>) -> StrongWriter

Create a new strong writer.

pub fn new_weak_writer(self: &Arc<Channel>) -> WeakWriter

Create a new weak writer that acquires tail slots on demand.

pub fn new_strong_reader(self: &Arc<Channel>) -> StrongReader

Create a new reader that applies backpressure to writers if they are trying to overwrite the reader’s log position.

Note that the entire channel will be as slow as the slowest strong reader.

pub fn new_weak_reader(self: &Arc<Channel>) -> WeakReader

Create a new reader that can be overtaken by writers if the reader is too slow.

If you require a reader that cannot lose any data, create a StrongReader instead.

pub fn reserve_slice(&self, len: u64) -> u64

Reserve a tail position of given length to write to.

Caution!

Failing to write the entire slice will result in permanent backpressure.

pub fn terminate(&self) -> Result<(), ChannelError>

Safely terminate this channel.

This will cause any readers or writers to return io::ErrorKind::ConnectionAborted.

pub fn drain(&self) -> Result<(), ChannelError>

Start draining the channel.

When draining, a channel doesn’t accept any new frames from Writers, and rejects reads once they catch up to the buffer tail.

Trait Implementations

impl Drop for Channel

fn drop(&mut self)

Executes the destructor for this type.