Trait actix::AsyncContext
source · pub trait AsyncContext<A>: ActorContextwhere
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
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,
{ ... }
fn run_interval<F>(&mut self, dur: Duration, f: F) -> SpawnHandle
where
F: FnMut(&mut A, &mut A::Context) + 'static,
{ ... }
}
Expand description
Asynchronous execution context
Required Methods§
sourcefn spawn<F>(&mut self, fut: F) -> SpawnHandlewhere
F: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
fn spawn<F>(&mut self, fut: F) -> SpawnHandlewhere
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.
sourcefn wait<F>(&mut self, fut: F)where
F: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
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.
sourcefn waiting(&self) -> bool
fn waiting(&self) -> bool
Check if context is paused (waiting for future completion or stopping)
sourcefn cancel_future(&mut self, handle: SpawnHandle) -> bool
fn cancel_future(&mut self, handle: SpawnHandle) -> bool
Cancel future. handle is a value returned by spawn
method.
Provided Methods§
sourcefn add_stream<S>(&mut self, fut: S) -> SpawnHandlewhere
S: Stream + 'static,
A: StreamHandler<S::Item, S::Error>,
fn add_stream<S>(&mut self, fut: S) -> SpawnHandlewhere
S: Stream + 'static,
A: StreamHandler<S::Item, S::Error>,
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)));
}
}
sourcefn add_message_stream<S>(&mut self, fut: S)where
S: Stream<Error = ()> + 'static,
S::Item: Message,
A: Handler<S::Item>,
fn add_message_stream<S>(&mut self, fut: S)where
S: Stream<Error = ()> + 'static,
S::Item: Message,
A: Handler<S::Item>,
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)));
}
}
sourcefn notify<M>(&mut self, msg: M)where
A: Handler<M>,
M: Message + 'static,
fn notify<M>(&mut self, msg: M)where
A: Handler<M>,
M: Message + 'static,
Send message msg
to self.
sourcefn notify_later<M>(&mut self, msg: M, after: Duration) -> SpawnHandlewhere
A: Handler<M>,
M: Message + 'static,
fn notify_later<M>(&mut self, msg: M, after: Duration) -> SpawnHandlewhere
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.
sourcefn run_later<F>(&mut self, dur: Duration, f: F) -> SpawnHandlewhere
F: FnOnce(&mut A, &mut A::Context) + 'static,
fn run_later<F>(&mut self, dur: Duration, f: F) -> SpawnHandlewhere
F: FnOnce(&mut A, &mut A::Context) + 'static,
Execute closure after specified period of time within same Actor and Context. Execution get cancelled if context’s stop method get called.
sourcefn run_interval<F>(&mut self, dur: Duration, f: F) -> SpawnHandlewhere
F: FnMut(&mut A, &mut A::Context) + 'static,
fn run_interval<F>(&mut self, dur: Duration, f: F) -> SpawnHandlewhere
F: FnMut(&mut A, &mut A::Context) + 'static,
Spawns a job to execute the given closure periodically, at a specified fixed interval