pub trait Sink {
type Item;
// Required method
fn poll_send(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
value: Self::Item,
) -> PollSend<Self::Item>;
// Provided methods
fn send(&mut self, value: Self::Item) -> SendFuture<'_, Self> ⓘ { ... }
fn try_send(
&mut self,
value: Self::Item,
) -> Result<(), TrySendError<Self::Item>>
where Self: Unpin { ... }
fn after<Before>(self, before: Before) -> ChainSink<Before, Self>
where Before: Sink<Item = Self::Item>,
Self: Sized { ... }
fn filter<Filter>(self, filter: Filter) -> FilterSink<Filter, Self>
where Filter: FnMut(&Self::Item) -> bool,
Self: Sized { ... }
}Expand description
A sink which can asynchronously accept messages, and at some point may refuse to accept any further messages.
Sinks implement poll_send, a poll-based method very similar to std::future::Future.
Sinks can be used in async code with stream.send(value).await, or with stream.try_send(value). Note that
send returns an error if the sink has been closed. And try_send returns an error if the sink is full, or it is closed.
Send errors can be ignored using Result::ok.
use postage::mpsc::channel;
use postage::sink::{Sink, TrySendError};
#[tokio::main]
async fn main() -> Result<(), TrySendError<bool>> {
let (mut tx, mut rx) = channel(16);
tx.send(true).await.ok();
tx.try_send(true)?;
drop(tx);
Ok(())
}Sinks also support combinators, such as map, filter, chain, and log.
use postage::mpsc::channel;
use postage::sink::{Sink, SendError, TrySendError};
use postage::stream::Stream;
#[tokio::main]
async fn main() {
let (mut tx, mut rx) = channel(16);
let (tx2, mut rx2) = channel(16);
let mut combo = tx2
.after(tx)
.filter(|i| *i >= 2);
// The `logging` feature enables a combinator that logs values using the Debug trait.
#[cfg(feature = "logging")]
let mut combo = combo
.log(log::Level::Info);
combo.send(1usize).await.ok();
combo.send(2usize).await.ok();
assert_eq!(Some(2usize), rx.recv().await);
drop(rx);
combo.send(3usize).await.ok();
combo.send(4usize).await.ok();
assert_eq!(Some(3usize), rx2.recv().await);
assert_eq!(Some(4usize), rx2.recv().await);
drop(rx2);
assert_eq!(Err(SendError(5usize)), combo.send(5usize).await);
}Required Associated Types§
Required Methods§
Sourcefn poll_send(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
value: Self::Item,
) -> PollSend<Self::Item>
fn poll_send( self: Pin<&mut Self>, cx: &mut Context<'_>, value: Self::Item, ) -> PollSend<Self::Item>
Attempts to accept the message, without blocking.
Returns:
PollSend::Readyif the value was sentPollSend::Pending(value)if the channel is full. The channel will call the waker incxwhen the item may be accepted in the future.PollSend::Rejected(value)if the channel is closed, and will never accept the item.
Provided Methods§
Sourcefn send(&mut self, value: Self::Item) -> SendFuture<'_, Self> ⓘ
fn send(&mut self, value: Self::Item) -> SendFuture<'_, Self> ⓘ
Attempts to send a message into the sink.
Returns:
Ok(())if the value was accepted.Err(SendError(value))if the sink rejected the message.
Sourcefn try_send(
&mut self,
value: Self::Item,
) -> Result<(), TrySendError<Self::Item>>where
Self: Unpin,
fn try_send(
&mut self,
value: Self::Item,
) -> Result<(), TrySendError<Self::Item>>where
Self: Unpin,
Attempts to send a message over the sink, without blocking.
Returns:
Ok(())if the value was accepted.Err(TrySendError::Pending(value))if the channel is full, and cannot accept the item at this time.Err(TrySendError::Rejected(value))if the channel is closed, and will never accept the item.
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.