pub struct GenericChannel<MutexType: RawMutex, T, A>where
A: RingBuf<Item = T>,{ /* private fields */ }Expand description
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 i32 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§
Source§impl<MutexType: RawMutex, T, A> GenericChannel<MutexType, T, A>where
A: RingBuf<Item = T>,
impl<MutexType: RawMutex, T, A> GenericChannel<MutexType, T, A>where
A: RingBuf<Item = T>,
Sourcepub fn new() -> Self
pub fn new() -> Self
Creates a new Channel, utilizing the default capacity that
the RingBuffer in A provides.
Sourcepub fn with_capacity(capacity: usize) -> Self
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.
Sourcepub fn send(&self, value: T) -> ChannelSendFuture<'_, MutexType, T> ⓘ
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.
Sourcepub fn try_send(&self, value: T) -> Result<(), TrySendError<T>>
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.
Sourcepub fn receive(&self) -> ChannelReceiveFuture<'_, MutexType, T> ⓘ
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.
Sourcepub fn try_receive(&self) -> Result<T, TryReceiveError>
pub fn try_receive(&self) -> Result<T, TryReceiveError>
Attempt to receive a value of the channel without waiting.
Sourcepub fn stream(&self) -> ChannelStream<'_, MutexType, T, A>
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.
Sourcepub fn close(&self) -> CloseStatus
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.