Struct futures::unsync::oneshot::Sender
[−]
[src]
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>
[src]
fn send(self, val: T) -> Result<(), T>
[src]
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.
fn poll_cancel(&mut self) -> Poll<(), ()>
[src]
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.
fn is_canceled(&self) -> bool
[src]
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.