Struct futures::sync::mpsc::Sender

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

The transmission end of a channel which is used to send values.

This is created by the channel method.

Methods

impl<T> Sender<T>

pub fn try_send(&mut self, msg: T) -> Result<(), TrySendError<T>>

Attempts to send a message on this Sender<T> without blocking.

This function, unlike start_send, is safe to call whether it's being called on a task or not. Note that this function, however, will not attempt to block the current task if the message cannot be sent.

It is not recommended to call this function from inside of a future, only from an external thread where you've otherwise arranged to be notified when the channel is no longer full.

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

Polls the channel to determine if there is guaranteed to be capacity to send at least one item without waiting.

Returns Ok(Async::Ready(_)) if there is sufficient capacity, or returns Ok(Async::NotReady) if the channel is not guaranteed to have capacity. Returns Err(SendError(_)) if the receiver has been dropped.

Panics

This method will panic if called from outside the context of a task or future.

pub fn is_closed(&self) -> bool

Returns whether this channel is closed without needing a context.

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> Sink for Sender<T>

type SinkItem = T

The type of value that the sink accepts.

type SinkError = SendError<T>

The type of value produced by the sink when an error occurs.

fn start_send(&mut self, msg: T) -> StartSend<T, SendError<T>>

Begin the process of sending a value to the sink.

fn poll_complete(&mut self) -> Poll<(), SendError<T>>

Flush all output from this sink, if necessary.

fn close(&mut self) -> Poll<(), SendError<T>>

A method to indicate that no more values will ever be pushed into this sink.

fn wait(self) -> Wait<Self> where     Self: Sized,

Creates a new object which will produce a synchronous sink.

fn with<U, F, Fut>(self, f: F) -> With<Self, U, F, Fut> where     F: FnMut(U) -> Fut,     Fut: IntoFuture<Item = Self::SinkItem>,     Fut::Error: From<Self::SinkError>,     Self: Sized,

Composes a function in front of the sink.

fn with_flat_map<U, F, St>(self, f: F) -> WithFlatMap<Self, U, F, St> where     F: FnMut(U) -> St,     St: Stream<Item = Self::SinkItem, Error = Self::SinkError>,     Self: Sized,

Composes a function in front of the sink.

fn sink_map_err<F, E>(self, f: F) -> SinkMapErr<Self, F> where     F: FnOnce(Self::SinkError) -> E,     Self: Sized,

Transforms the error returned by the sink.

fn sink_from_err<E: From<Self::SinkError>>(self) -> SinkFromErr<Self, E> where     Self: Sized,

Map this sink's error to any error implementing From for this sink's Error, returning a new sink.

fn buffer(self, amt: usize) -> Buffer<Self> where     Self: Sized,

Adds a fixed-size buffer to the current sink.

fn fanout<S>(self, other: S) -> Fanout<Self, S> where     Self: Sized,     Self::SinkItem: Clone,     S: Sink<SinkItem = Self::SinkItem, SinkError = Self::SinkError>,

Fanout items to multiple sinks.

fn flush(self) -> Flush<Self> where     Self: Sized,

A future that completes when the sink has finished processing all pending requests.

fn send(self, item: Self::SinkItem) -> Send<Self> where     Self: Sized,

A future that completes after the given item has been fully processed into the sink, including flushing.

fn send_all<S>(self, stream: S) -> SendAll<Self, S> where     S: Stream<Item = Self::SinkItem>,     Self::SinkError: From<S::Error>,     Self: Sized,

A future that completes after the given stream has been fully processed into the sink, including flushing.

impl<T> Clone for Sender<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Drop for Sender<T>

fn drop(&mut self)

Executes the destructor for this type.