# tokio_util::sync::PollSender - Rust
API documentation for the Rust `PollSender` struct in crate `tokio_util`.
Keywords: rust, rustlang, rust-lang, PollSender

# Struct tokio_util::sync::PollSender [−] [src]

    pub struct PollSender<T> { /* fields omitted */ }

A wrapper around `mpsc::Sender` that can be polled.

## Implementations

### `impl<T: Send + 'static> PollSender<T>` [src]

#### `pub fn new(sender: Sender<T>) -> Self` [src]

Create a new `PollSender`.

#### `pub fn start_send(&mut self, value: T) -> Result<(), SendError<T>>` [src]

Start sending a new item.

This method panics if a send is currently in progress. To ensure that no send is in progress, call `poll_send_done` first until it returns `Poll::Ready`.

If this method returns an error, that indicates that the channel is closed. Note that this method is not guaranteed to return an error if the channel is closed, but in that case the error would be reported by the first call to `poll_send_done`.

#### `pub fn poll_send_done(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), SendError<T>>>` [src]

If a send is in progress, poll for its completion. If no send is in progress, this method returns `Poll::Ready(Ok(()))`.

This method can return the following values:

- `Poll::Ready(Ok(()))` if the in-progress send has been completed, or there is no send in progress (even if the channel is closed).
- `Poll::Ready(Err(err))` if the in-progress send failed because the channel has been closed.
- `Poll::Pending` if a send is in progress, but it could not complete now.

When this method returns `Poll::Pending`, the current task is scheduled to receive a wakeup when the message is sent, or when the entire channel is closed (but not if just this sender is closed by `close_this_sender`). Note that on multiple calls to `poll_send_done`, only the `Waker` from the `Context` passed to the most recent call is scheduled to receive a wakeup.

If this method returns `Poll::Ready`, then `start_send` is guaranteed to not panic.

#### `pub fn is_ready(&self) -> bool` [src]

Check whether the channel is ready to send more messages now.

If this method returns `true`, then `start_send` is guaranteed to not panic.

If the channel is closed, this method returns `true`.

#### `pub fn is_closed(&self) -> bool` [src]

Check whether the channel has been closed.

#### `pub fn clone_inner(&self) -> Option<Sender<T>>` [src]

Clone the underlying `Sender`.

If this method returns `None`, then the channel is closed. (But it is not guaranteed to return `None` if the channel is closed.)

#### `pub fn inner_ref(&self) -> Option<&Sender<T>>` [src]

Access the underlying `Sender`.

If this method returns `None`, then the channel is closed. (But it is not guaranteed to return `None` if the channel is closed.)

#### `pub fn close_this_sender(&mut self)` [src]

Close this sender. No more messages can be sent from this sender.

Note that this only closes the channel from the view-point of this sender. The channel remains open until all senders have gone away, or until the `Receiver` closes the channel.

If there is a send in progress when this method is called, that send is unaffected by this operation, and `poll_send_done` can still be called to complete that send.

#### `pub fn abort_send(&mut self) -> bool` [src]

Abort the current in-progress send, if any.

Returns `true` if a send was aborted.

## Trait Implementations

### `impl<T> Clone for PollSender<T>` [src]

#### `fn clone(&self) -> PollSender<T>` [src]

Clones this `PollSender`. The resulting clone will not have any in-progress send operations, even if the current `PollSender` does.

#### `pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl<T: Debug> Debug for PollSender<T>` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl<T: Send + 'static> Sink<T> for PollSender<T>` [src]

#### `type Error = SendError<T>`

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>>` [src]

This is equivalent to calling `poll_send_done`.

#### `fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>` [src]

This is equivalent to calling `poll_send_done`.

#### `fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error>` [src]

This is equivalent to calling `start_send`.

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

This method will first flush the `PollSender`, and then close it by calling `close_this_sender`.

If a send fails while flushing because the `Receiver` has gone away, then this function returns an error. The channel is still successfully closed in this situation.

## Auto Trait Implementations

### `impl<T> !RefUnwindSafe for PollSender<T>` [src]

### `impl<T> Send for PollSender<T> where
T: Send,` [src]

### `impl<T> Sync for PollSender<T> where
T: Send,` [src]

### `impl<T> Unpin for PollSender<T>` [src]

### `impl<T> !UnwindSafe for PollSender<T>` [src]

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `pub fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `pub fn clone_into(&self, target: &mut T)` [src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.