Struct eventual::Sender

pub struct Sender<T: Send + 'static, E: Send + 'static> { /* fields omitted */ }

The sending half of Stream::pair(). Can only be owned by a single task at a time.

Methods

impl<T: Send + 'static, E: Send + 'static> Sender<T, E>

fn send(self, val: T) -> BusySender<T, E>

Attempts to send a value to its Stream. Consumes self and returns a future representing the operation completing successfully and interest in the next value being expressed.

fn fail(self, err: E)

Terminated the stream with the given error.

fn abort(self)

Fails the paired Stream with a cancellation error. This will eventually go away when carllerche/syncbox#10 lands. It is currently needed to keep the state correct (see async::sequence)

fn send_all<S: Source<Value = T>>(
    self,
    src: S
) -> Future<Self, (S::Error, Self)>

Send + 'static all the values in the given source

Trait Implementations

impl<T: Send + 'static, E: Send + 'static> Async for Sender<T, E>

type Value = Sender<T, E>

type Error = ()

type Cancel = Receipt<Sender<T, E>>

fn is_ready(&self) -> bool

Returns true if expect will succeed.

fn is_err(&self) -> bool

Returns true if the async value is ready and has failed

fn poll(self) -> Result<AsyncResult<Sender<T, E>, ()>, Sender<T, E>>

Get the underlying value if present

fn ready<F: FnOnce(Sender<T, E>) + Send + 'static>(
    self,
    f: F
) -> Receipt<Sender<T, E>>

Invokes the given function when the Async instance is ready to be consumed.

fn expect(self) -> AsyncResult<Self::Value, Self::Error>

Get the underlying value if present, panic otherwise

fn receive<F>(self, f: F) where
    F: FnOnce(AsyncResult<Self::Value, Self::Error>) + Send + 'static, 

Invoke the callback with the resolved Async result.

fn await(self) -> AsyncResult<Self::Value, Self::Error>

Blocks the thread until the async value is complete and returns the result.

fn fire(self)

Trigger the computation without waiting for the result

fn and<U: Async<Error = Self::Error>>(
    self,
    next: U
) -> Future<U::Value, Self::Error>

This method returns a future whose completion value depends on the completion value of the original future.

fn and_then<F, U: Async<Error = Self::Error>>(
    self,
    f: F
) -> Future<U::Value, Self::Error> where
    F: FnOnce(Self::Value) -> U + Send + 'static,
    U::Value: Send + 'static, 

This method returns a future whose completion value depends on the completion value of the original future.

fn or<A>(self, alt: A) -> Future<Self::Value, A::Error> where
    A: Async<Value = Self::Value>, 

This method returns a future whose completion value depends on the completion value of the original future.

fn or_else<F, A>(self, f: F) -> Future<Self::Value, A::Error> where
    F: FnOnce(Self::Error) -> A + Send + 'static,
    A: Async<Value = Self::Value>, 

This method returns a future whose completion value depends on the completion value of the original future.

impl<T: Send + 'static, E: Send + 'static> Drop for Sender<T, E>

fn drop(&mut self)

A method called when the value goes out of scope.

impl<T: Send + 'static, E: Send + 'static> Debug for Sender<T, E>

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

Formats the value using the given formatter.