Struct PendingSender 

pub struct PendingSender<T> { /* private fields */ }

A sender that is waiting for the channel to be established.

When creating channels, one of the channel ends is always claimed by the local client, depending on whether ChannelBuilder::claim_sender or claim_receiver is used. If the sender is claimed, then this will return a PendingSender.

PendingSenders are an intermediate step before the channel is fully established. It’s purpose is to wait until the other channel end is claimed as well.

Implementations

impl<T> PendingSender<T>

pub fn into_lowlevel(self) -> PendingSender

Converts the sender into a low-level PendingSender.

pub fn client(&self) -> &Handle

Returns a Handle to the associated client.

pub fn cookie(&self) -> ChannelCookie

Returns the ChannelCookie, which identifies this channel.

pub fn cast<U>(self) -> PendingSender<U>

Casts the item type to a different type U.

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

Initiates closing the sender and polls for progress.

See close for more information.

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

Closes the sender.

This will prevent the channel from being established. Any calls to UnclaimedReceiver::claim will return an error.

let (mut sender, receiver) = handle
    .create_channel::<String>()
    .claim_sender()
    .await?;

// Close the PendingSender:
sender.close().await?;

// Trying to claim the UnclaimedReceiver will fail:
let res = receiver.claim(16).await;
assert_eq!(res.unwrap_err(), Error::InvalidChannel);

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

Polls the channel for whether it has been established.

When this method returns Poll::Ready(()), then establish will resolve immediately.

Note that this method does not indicate errors. You must use establish to check whether the channel was successfully established.

pub async fn wait_established(&mut self)

Waits until the channel has been established.

When this method returns, then establish will resolve immediately.

Note that this method does not indicate errors. You must use establish to check whether the channel was successfully established.

pub async fn establish(self) -> Result<Sender<T>, Error>

Waits until the channel has been established and returns a Sender.

It can occasionally be useful to only wait until the channel is established, but without converting self to a Sender. This can e.g. happen in select! macros or similar situations. The reason is, that this method takes self by value and is not cancel-safe. Use wait_established in such cases.

let (sender, receiver) = handle
    .create_channel::<String>()
    .claim_sender()
    .await?;

// Claim the receiver:
let mut receiver = receiver.claim(16).await?;

// The channel is now established:
let mut sender = sender.establish().await?;

sender.send_item("Hello :)").await?;
let item = receiver.next_item().await?;
assert_eq!(item.as_deref(), Some("Hello :)"));

Trait Implementations

impl<T> Debug for PendingSender<T>

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

Formats the value using the given formatter.