Trait actix_web::actix::AsyncContext

pub trait AsyncContext<A>: ActorContext where
    A: Actor<Context = Self>, {
    fn address(&self) -> Addr<A>;
    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 add_stream<S>(&mut self, fut: S) -> SpawnHandle
    where
        A: StreamHandler<<S as Stream>::Item, <S as Stream>::Error>,
        S: Stream + 'static,
    { ... }
    fn add_message_stream<S>(&mut self, fut: S)
    where
        A: Handler<<S as Stream>::Item>,
        S: Stream<Error = ()> + 'static,
        <S as Stream>::Item: Message,
    { ... }
    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 as Actor>::Context) + 'static,
    { ... }
    fn run_interval<F>(&mut self, dur: Duration, f: F) -> SpawnHandle
    where
        F: FnMut(&mut A, &mut <A as Actor>::Context) + 'static,
    { ... }
}

Asynchronous execution context

Required methods

fn address(&self) -> Addr<A>

Return Address of the context

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

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

All futures cancel during actor stopping stage.

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

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

fn waiting(&self) -> bool

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

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

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

Loading content...

Provided methods

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

This method register stream to an actor context and allows to handle Stream in similar way as normal actor messages.

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)));
   }
}

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

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)));
    }
}

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

Send message msg to self.

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

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.

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

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

fn run_interval<F>(&mut self, dur: Duration, f: F) -> SpawnHandle where
    F: FnMut(&mut A, &mut <A as Actor>::Context) + 'static, 

Spawns a job to execute the given closure periodically, at a specified fixed interval

Loading content...

Implementors

impl<A> AsyncContext<A> for Context<A> where
    A: Actor<Context = Context<A>>, 

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(&self) -> Addr<A>

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

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

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 as Actor>::Context) + 'static, 

fn run_interval<F>(&mut self, dur: Duration, f: F) -> SpawnHandle where
    F: FnMut(&mut A, &mut <A as Actor>::Context) + 'static, 

impl<A, S> AsyncContext<A> for HttpContext<A, S> 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 cancel_future(&mut self, handle: SpawnHandle) -> bool

fn address(&self) -> Addr<A>

fn waiting(&self) -> bool

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

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

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 as Actor>::Context) + 'static, 

fn run_interval<F>(&mut self, dur: Duration, f: F) -> SpawnHandle where
    F: FnMut(&mut A, &mut <A as Actor>::Context) + 'static, 

impl<A, S> AsyncContext<A> for WebsocketContext<A, S> 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 cancel_future(&mut self, handle: SpawnHandle) -> bool

fn address(&self) -> Addr<A>

fn waiting(&self) -> bool

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

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

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 as Actor>::Context) + 'static, 

fn run_interval<F>(&mut self, dur: Duration, f: F) -> SpawnHandle where
    F: FnMut(&mut A, &mut <A as Actor>::Context) + 'static, 

Loading content...