Struct aldrin::Sender

pub struct Sender<T: Serialize + ?Sized> { /* private fields */ }

The sending end of an established channel.

This type of sender is obtained when a channel has been fully established, either by PendingSender::established or by UnclaimedSender::claim.

Implementations

impl<T: Serialize + ?Sized> Sender<T>

pub fn cast<U: Serialize + ?Sized>(self) -> Sender<U>

Casts the item type to a different type.

pub fn poll_send_ready( &mut self, cx: &mut Context<'_> ) -> Poll<Result<(), Error>>

Polls the channel for capacity to send at least 1 item.

pub async fn send_ready(&mut self) -> Result<(), Error>

Waits until the channel has capacity to send at least 1 item.

pub fn start_send_item(&mut self, item: &T) -> Result<(), Error>

Sends an item on the channel.

This function panics if the channel doesn’t have any capacity left. You must call either send_ready or poll_send_ready before to ensure there is capacity.

pub async fn send_item(&mut self, item: &T) -> Result<(), Error>

Sends an item on the channel.

This function will wait until the channel has capacity to send at least 1 item.

pub async fn close(&mut self) -> Result<(), Error>

Closes the sender without consuming it.

The will cause the receiving end to receive None after all other items have been received.

Examples

let (sender, receiver) = handle.create_channel_with_claimed_sender().await?;

let mut receiver = receiver.claim(16).await?;
let mut sender = sender.established().await?;

// Send a couple of items and then close the sender.
sender.send_item(&1).await?;
sender.send_item(&2).await?;
sender.send_item(&3).await?;
sender.close().await?;

// The receiver will receive all items followed by None.
assert_eq!(receiver.next_item().await, Ok(Some(1)));
assert_eq!(receiver.next_item().await, Ok(Some(2)));
assert_eq!(receiver.next_item().await, Ok(Some(3)));
assert_eq!(receiver.next_item().await, Ok(None));

pub fn is_closed(&self) -> bool

Returns true if the channel is closed.

pub fn poll_closed(&mut self, cx: &mut Context<'_>) -> Poll<()>

Polls whether the channel is closed.

pub async fn closed(&mut self)

Completes when the channel is closed.

Trait Implementations

impl<T: Debug + Serialize + ?Sized> Debug for Sender<T>

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

Formats the value using the given formatter.

impl<T: Serialize + ?Sized> Sink<&T> for Sender<T>

type Error = Error

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: &T) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, _cx: &mut Context<'_> ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<T: Serialize> Sink<T> for Sender<T>

type Error = Error

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, _cx: &mut Context<'_> ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.