Struct Complete 

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

An object that is used to fulfill or reject an associated Future.

use eventual::*;

let (tx, future) = Future::<u32, &'static str>::pair();

future.and_then(|v| {
    assert!(v == 1);
    Ok(v + v)
}).fire();

tx.complete(1);

let (tx, future) = Future::<u32, &'static str>::pair();
tx.fail("failed");

future.or_else(|err| {
    assert!(err == "failed");
    Ok::<u32, &'static str>(123)
}).fire();

Implementations

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

pub fn complete(self, val: T)

Fulfill the associated promise with a value

pub fn fail(self, err: E)

Reject the associated promise with an error. The error will be wrapped in Async::Error::Failed.

pub fn abort(self)

pub fn is_ready(&self) -> bool

pub fn is_err(&self) -> bool

pub fn ready<F: FnOnce(Complete<T, E>) + Send + 'static>(self, f: F)

pub fn await(self) -> AsyncResult<Complete<T, E>, ()>

Trait Implementations

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

type Value = Complete<T, E>

type Error = ()

type Cancel = Receipt<Complete<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<Complete<T, E>, ()>, Complete<T, E>>

Get the underlying value if present

fn ready<F: FnOnce(Complete<T, E>) + Send + 'static>( self, f: F, ) -> Receipt<Complete<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> Cancel<Complete<T, E>> for Receipt<Complete<T, E>>

fn cancel(self) -> Option<Complete<T, E>>

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

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.