Trait actix::AsyncContext [−] [src]

pub trait AsyncContext<A>: ActorContext where
    A: Actor<Context = Self>, {
    fn spawn<F>(&mut self, fut: F) -> SpawnHandle
    where
        F: ActorFuture<Item = (), Error = (), Actor = A> + 'static;

    fn wait<F>(&mut self, fut: F)
    where
        F: ActorFuture<Item = (), Error = (), Actor = A> + 'static;

    fn waiting(&self) -> bool;

    fn cancel_future(&mut self, handle: SpawnHandle) -> bool;

    fn address<Address>(&mut self) -> Address
    where
        A: ActorAddress<A, Address>,
    { ... }

    fn add_stream<S>(&mut self, fut: S) -> SpawnHandle
    where
        S: Stream + 'static,
        A: StreamHandler<S::Item, S::Error>,
    { ... }

    fn add_message_stream<S>(&mut self, fut: S)
    where
        S: Stream<Error = ()> + 'static,
        S::Item: Message,
        A: Handler<S::Item>,
    { ... }

    fn notify<M>(&mut self, msg: M)
    where
        A: Handler<M>,
        M: Message + 'static,
    { ... }

    fn notify_later<M>(&mut self, msg: M, after: Duration) -> SpawnHandle
    where
        A: Handler<M>,
        M: Message + 'static,
    { ... }

    fn run_later<F>(&mut self, dur: Duration, f: F) -> SpawnHandle
    where
        F: FnOnce(&mut A, &mut A::Context) + 'static,
    { ... }
}

Asynchronous execution context

Required Methods

Spawn async future into context. Returns handle of the item, could be used for cancelling execution.

All futures cancel during actor stopping stage.

Spawn future into the context. Stop processing any of incoming events until this future resolves.

Check if context is paused (waiting for future completion or stopping)

Cancel future. idx is a value returned by spawn method.

Provided Methods

Get actor address

This method allow to handle Stream in similar way as normal actor messages.

Information to consider. Actor wont receive next item from a stream until Response future resolves to a result.

This method is similar to add_stream but it skips result error.

use actix::prelude::*;
use futures::stream::once;

#[derive(Message)]
struct Ping;

struct MyActor;

impl StreamHandler<Ping, io::Error> for MyActor {

    fn handle(&mut self, item: Ping, ctx: &mut Context<MyActor>) {
        println!("PING");
    }

    fn finished(&mut self, ctx: &mut Self::Context) {
        println!("finished");
    }
}

impl Actor for MyActor {
   type Context = Context<Self>;

   fn started(&mut self, ctx: &mut Context<Self>) {
       // add stream
       ctx.add_stream(once::<Ping, io::Error>(Ok(Ping)));
   }
}

This method is similar to add_stream but it skips stream errors.

use actix::prelude::*;
use futures::stream::once;

#[derive(Message)]
struct Ping;

struct MyActor;

impl Handler<Ping> for MyActor {
    type Result = ();

    fn handle(&mut self, msg: Ping, ctx: &mut Context<MyActor>) {
        println!("PING");
    }
}

impl Actor for MyActor {
   type Context = Context<Self>;

   fn started(&mut self, ctx: &mut Context<Self>) {
       // add messages stream
       ctx.add_message_stream(once(Ok(Ping)));
   }
}

Send message msg to self.

Send message msg to self after specified period of time. Returns spawn handle which could be used for cancellation. Notification get cancelled if context's stop method get called.

Execute closure after specified period of time within same Actor and Context. Execution get cancelled if context's stop method get called.

Implementors