Struct futures::unsync::oneshot::Sender

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

Represents the completion half of a oneshot through which the result of a computation is signaled.

This is created by the unsync::oneshot::channel function and is equivalent in functionality to sync::oneshot::Sender except that it cannot be sent across threads.

Methods

impl<T> Sender<T>

pub fn send(self, val: T) -> Result<(), T>

Completes this oneshot with a successful result.

This function will consume self and indicate to the other end, the Receiver, that the error provided is the result of the computation this represents.

If the value is successfully enqueued for the remote end to receive, then Ok(()) is returned. If the receiving end was deallocated before this function was called, however, then Err is returned with the value provided.

pub fn poll_cancel(&mut self) -> Poll<(), ()>

Polls this Sender half to detect whether the Receiver this has paired with has gone away.

This function can be used to learn about when the Receiver (consumer) half has gone away and nothing will be able to receive a message sent from complete.

Like Future::poll, this function will panic if it's not called from within the context of a task. In other words, this should only ever be called from inside another future.

If Ready is returned then it means that the Receiver has disappeared and the result this Sender would otherwise produce should no longer be produced.

If NotReady is returned then the Receiver is still alive and may be able to receive a message if sent. The current task, however, is scheduled to receive a notification if the corresponding Receiver goes away.

pub fn is_canceled(&self) -> bool

Tests to see whether this Sender's corresponding Receiver has gone away.

This function can be used to learn about when the Receiver (consumer) half has gone away and nothing will be able to receive a message sent from send.

Note that this function is intended to not be used in the context of a future. If you're implementing a future you probably want to call the poll_cancel function which will block the current task if the cancellation hasn't happened yet. This can be useful when working on a non-futures related thread, though, which would otherwise panic if poll_cancel were called.

Trait Implementations

impl<T: Debug> Debug for Sender<T>

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

Formats the value using the given formatter.

impl<T> Drop for Sender<T>

fn drop(&mut self)

Executes the destructor for this type.