[−][src]Trait actix::fut::ActorFuture

pub trait ActorFuture {
    type Output;
    type Actor: Actor;
    fn poll(
        self: Pin<&mut Self>, 
        srv: &mut Self::Actor, 
        ctx: &mut <Self::Actor as Actor>::Context, 
        task: &mut Context
    ) -> Poll<Self::Output>;

    fn map<F, U>(self, f: F) -> Map<Self, F>
    where
        F: FnOnce(Self::Output, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,
        Self: Sized,
    { ... }

    fn then<F, B>(self, f: F) -> Then<Self, B, F>
    where
        F: FnOnce(Self::Output, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> B,
        B: IntoActorFuture<Actor = Self::Actor>,
        Self: Sized,
    { ... }

    fn timeout(self, timeout: Duration) -> Timeout<Self>
    where
        Self: Sized,
    { ... }
}

Trait for types which are a placeholder of a value that may become available at some later point in time.

ActorFuture is very similar to a regular Future, only with subsequent combinator closures accepting the actor and its context, in addition to the result.

ActorFuture allows for use cases where future processing requires access to the actor or its context.

Here is an example of a handler on a single actor, deferring work to another actor, and then updating the initiating actor's state:

ⓘThis example is not tested
// The response type returned by the actor future
type OriginalActorResponse = ();
// The error type returned by the actor future
type MessageError = ();
// This is the needed result for the DeferredWork message
// It's a result that combine both Response and Error from the future response.
type DeferredWorkResult = Result<OriginalActorResponse, MessageError>;









impl Message for DeferredWork {
    type Result = DeferredWorkResult;
}


impl Handler<DeferredWork> for OriginalActor {
    // Notice the `Response` is an `ActorFuture`-ized version of `Self::Message::Result`.
    type Result = ResponseActFuture<Self, OriginalActorResponse, MessageError>;

    fn handle(&mut self, _msg: DeferredWork, _ctx: &mut Context<Self>) -> Self::Result {
        // this creates a `Future` representing the `.send` and subsequent `Result` from
        // `other_actor`
        let send_to_other = self.other_actor
            .send(OtherMessage {})
            .map_err(|_error| ());

        // Wrap that `Future` so subsequent chained handlers can access
        // the `actor` (`self` in the  synchronous code) as well as the context.
        let send_to_other = actix::fut::wrap_future::<_, Self>(send_to_other);

        // once the wrapped future resolves, update this actor's state
        let update_self = send_to_other.map(|result, actor, _ctx| {
            // Actor's state updated here
            actor.inner_state.update_from(result);
        });

        // return the wrapped future
        Box::new(update_self)
    }
}

See also into_actor, which provides future conversion using trait

Associated Types

type Output

The type of value that this future will resolved with if it is successful.

type Actor: Actor

The actor within which this future runs

Loading content...

Required methods

fn poll(
    self: Pin<&mut Self>,
    srv: &mut Self::Actor,
    ctx: &mut <Self::Actor as Actor>::Context,
    task: &mut Context
) -> Poll<Self::Output>

Loading content...

Provided methods

fn map<F, U>(self, f: F) -> Map<Self, F> where
    F: FnOnce(Self::Output, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,
    Self: Sized, 

Map this future's result to a different type, returning a new future of the resulting type.

fn then<F, B>(self, f: F) -> Then<Self, B, F> where
    F: FnOnce(Self::Output, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> B,
    B: IntoActorFuture<Actor = Self::Actor>,
    Self: Sized, 

Chain on a computation for when a future finished, passing the result of the future to the provided closure f.

fn timeout(self, timeout: Duration) -> Timeout<Self> where
    Self: Sized, 

Add timeout to futures chain.

err value get returned as a timeout error.

Loading content...

Implementations on Foreign Types

impl<F: ActorFuture + ?Sized> ActorFuture for Box<F>[src]

type Output = F::Output

type Actor = F::Actor

Loading content...

Implementors

impl ActorFuture for TcpConnector[src]

type Output = Result<TcpStream, ResolverError>

type Actor = Resolver

impl<A> ActorFuture for TimerFunc<A> where
    A: Actor, [src]

type Output = ()

type Actor = A

impl<A, B> ActorFuture for Either<A, B> where
    A: ActorFuture,
    B: ActorFuture<Output = A::Output, Actor = A::Actor>, [src]

type Output = A::Output

type Actor = A::Actor

impl<A, B, F> ActorFuture for Then<A, B, F> where
    A: ActorFuture,
    B: IntoActorFuture<Actor = A::Actor>,
    F: FnOnce(A::Output, &mut A::Actor, &mut <A::Actor as Actor>::Context) -> B, [src]

type Output = B::Output

type Actor = A::Actor

impl<F> ActorFuture for Timeout<F> where
    F: ActorFuture, [src]

type Output = Result<F::Output, ()>

type Actor = F::Actor

impl<F, A> ActorFuture for FutureWrap<F, A> where
    F: Future,
    A: Actor, [src]

type Output = F::Output

type Actor = A

impl<S, F, Fut, T> ActorFuture for StreamFold<S, F, Fut, T> where
    S: ActorStream + Unpin,
    F: FnMut(T, S::Item, &mut S::Actor, &mut <S::Actor as Actor>::Context) -> Fut,
    Fut: IntoActorFuture<Output = T, Actor = S::Actor>,
    Fut::Future: ActorFuture + Unpin, [src]

type Output = T

type Actor = S::Actor

impl<S: ActorStream> ActorFuture for StreamFinish<S> where
    S: ActorStream + Unpin,
    Self: Unpin, [src]

type Output = ()

type Actor = S::Actor

impl<T, A> ActorFuture for Ready<T, A> where
    A: Actor, [src]

type Output = T

type Actor = A

impl<T, E, A> ActorFuture for FutureResult<T, E, A> where
    A: Actor, [src]

type Output = Result<T, E>

type Actor = A

impl<U, A, F> ActorFuture for Map<A, F> where
    A: ActorFuture,
    F: FnOnce(A::Output, &mut A::Actor, &mut <A::Actor as Actor>::Context) -> U, [src]

type Output = U

type Actor = A::Actor

Loading content...