Struct futures_intrusive::channel::GenericChannel

pub struct GenericChannel<MutexType: RawMutex, T, A> where
    A: RingBuf<Item = T>,  { /* fields omitted */ }

A channel which can be used to exchange values of type T between concurrent tasks.

A represents the backing buffer for a Channel. E.g. a channel which can buffer up to 4 u32 values can be created via:

let channel: LocalChannel<i32, [i32; 4]> = LocalChannel::new();

Tasks can receive values from the channel through the receive method. The returned Future will get resolved when a value is sent into the channel. Values can be sent into the channel through send. The returned Future will get resolved when the value has been stored inside the channel.

Implementations

impl<MutexType: RawMutex, T, A> GenericChannel<MutexType, T, A> where
    A: RingBuf<Item = T>, 

pub fn new() -> Self

Creates a new Channel, utilizing the default capacity that the RingBuffer in A provides.

pub fn with_capacity(capacity: usize) -> Self

Creates a new Channel, which has storage for a capacity items. Depending on the utilized RingBuf type, the capacity argument might be ignored and the default capacity might be utilized.

pub fn send(&self, value: T) -> ChannelSendFuture<'_, MutexType, T>

Returns a future that gets fulfilled when the value has been written to the channel. If the channel gets closed while the send is in progress, sending the value will fail, and the future will deliver the value back.

pub fn try_send(&self, value: T) -> Result<(), TrySendError<T>>

Attempt to send the value without waiting.

This operation is not supported for unbuffered channels and will panic if the capacity of the RingBuf is zero. The reason for this is that the actual value transfer on unbuffered channels always happens when a receiving task copies the value out of the sending task while it is waiting. If the sending task does not wait, the value can not be transferred. Since this method can therefore never yield a reasonable result with unbuffered channels, it panics in order to highlight the use of an inappropriate API.

pub fn receive(&self) -> ChannelReceiveFuture<'_, MutexType, T>

Returns a future that gets fulfilled when a value is written to the channel. If the channels gets closed, the future will resolve to None.

pub fn try_receive(&self) -> Result<T, TryReceiveError>

Attempt to receive a value of the channel without waiting.

pub fn stream(&self) -> ChannelStream<'_, MutexType, T, A>

Returns a stream that will receive values from this channel.

This stream does not yield None when the channel is empty, instead it yields None when it is terminated.

pub fn close(&self) -> CloseStatus

Closes the channel. All pending and future send attempts will fail. Receive attempts will continue to succeed as long as there are items stored inside the channel. Further attempts will fail.

Trait Implementations

impl<MutexType: RawMutex, T, A> Debug for GenericChannel<MutexType, T, A> where
    A: RingBuf<Item = T>, 

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

Formats the value using the given formatter.

impl<MutexType: RawMutex + Send, T: Send, A> Send for GenericChannel<MutexType, T, A> where
    A: RingBuf<Item = T> + Send, 

impl<MutexType: RawMutex + Sync, T: Send, A> Sync for GenericChannel<MutexType, T, A> where
    A: RingBuf<Item = T>,