Struct actix::AtomicResponse

pub struct AtomicResponse<A, T>(_);

A specialized actor future holder for atomic asynchronous message handling.

Intended be used when the future returned will need exclusive access Actor's internal state or context, e.g., it can yield at critical sessions. When the actor starts to process this future, it will not pull any other spawned futures until this one as been completed. Check ActorFuture for available methods for accessing Actor's internal state.

Note

The runtime itself is not blocked in the process, only the Actor, other futures, and therefore, other actors are still allowed to make progress when this AtomicResponse is used.

Examples

On the following example, the response to Msg would always be 29 even if there are multiple Msg sent to MyActor.

impl Handler<Msg> for MyActor {
    type Result = AtomicResponse<Self, usize>;

    fn handle(&mut self, _: Msg, _: &mut Context<Self>) -> Self::Result {
        AtomicResponse::new(Box::pin(
            async {}
                .into_actor(self)
                .map(|_, this, _| {
                    this.0 = 30;
                })
                .then(|_, this, _| {
                    delay_for(Duration::from_secs(3)).into_actor(this)
                })
                .map(|_, this, _| {
                    this.0 -= 1;
                    this.0
                }),
        ))
    }
}

Implementations

impl<A, T> AtomicResponse<A, T>

pub fn new(fut: ResponseActFuture<A, T>) -> Self

Trait Implementations

impl<A, M, T: 'static> MessageResponse<A, M> for AtomicResponse<A, T> where
    A: Actor,
    M: Message<Result = T>,
    A::Context: AsyncContext<A>, 

fn handle<R: ResponseChannel<M>>(self, ctx: &mut A::Context, tx: Option<R>)