Struct tokio_util::sync::PollSender

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

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

Implementations

impl<T: Send + 'static> PollSender<T>

pub fn new(sender: Sender<T>) -> Self

Creates a new PollSender.

pub fn poll_reserve(
    &mut self,
    cx: &mut Context<'_>
) -> Poll<Result<(), PollSendError<T>>>

Attempts to prepare the sender to receive a value.

This method must be called and return Poll::Ready(Ok(())) prior to each call to send_item.

This method returns Poll::Ready once the underlying channel is ready to receive a value, by reserving a slot in the channel for the item to be sent. If this method returns Poll::Pending, the current task is registered to be notified (via cx.waker().wake_by_ref()) when poll_reserve should be called again.

Errors

If the channel is closed, an error will be returned. This is a permanent state.

pub fn send_item(&mut self, value: T) -> Result<(), PollSendError<T>>

Sends an item to the channel.

Before calling send_item, poll_reserve must be called with a successful return value of Poll::Ready(Ok(())).

Errors

If the channel is closed, an error will be returned. This is a permanent state.

Panics

If poll_reserve was not successfully called prior to calling send_item, then this method will panic.

pub fn is_closed(&self) -> bool

Checks whether this sender is been closed.

The underlying channel that this sender was wrapping may still be open.

pub fn get_ref(&self) -> Option<&Sender<T>>

Gets a reference to the Sender of the underlying channel.

If PollSender has been closed, None is returned. The underlying channel that this sender was wrapping may still be open.

pub fn close(&mut self)

Closes this sender.

No more messages will be able to be sent from this sender, but the underlying channel will remain open until all senders have dropped, or until the Receiver closes the channel.

If a slot was previously reserved by calling poll_reserve, then a final call can be made to send_item in order to consume the reserved slot. After that, no further sends will be possible. If you do not intend to send another item, you can release the reserved slot back to the underlying sender by calling abort_send.

pub fn abort_send(&mut self) -> bool

Aborts the current in-progress send, if any.

Returns true if a send was aborted. If the sender was closed prior to calling abort_send, then the sender will remain in the closed state, otherwise the sender will be ready to attempt another send.

Trait Implementations

impl<T> Clone for PollSender<T>

fn clone(&self) -> PollSender<T>

Clones this PollSender.

The resulting PollSender will have an initial state identical to calling PollSender::new.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for PollSender<T>

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

Formats the value using the given formatter.

impl<T: Send + 'static> Sink<T> for PollSender<T>

type Error = PollSendError<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>>

Attempts to prepare the Sink to receive a value.

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

Flush any remaining output from this sink.

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_close(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>>

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