Trait actix::AsyncContext[−][src]

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<A, Output = ()> + 'static;

    fn wait<F>(&mut self, fut: F)
    where
        F: ActorFuture<A, Output = ()> + '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>,
    { ... }

    fn add_message_stream<S>(&mut self, fut: S)
    where
        S: Stream + '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,
    { ... }
}

Asynchronous execution context.

Required methods

fn address(&self) -> Addr<A>[src]

Returns the address of the context.

fn spawn<F>(&mut self, fut: F) -> SpawnHandle where
    F: ActorFuture<A, Output = ()> + 'static, [src]

Spawns a future into the context.

Returns a handle of the spawned future, which can be used for cancelling its execution.

All futures spawned into an actor’s context are cancelled during the actor’s stopping stage.

fn wait<F>(&mut self, fut: F) where
    F: ActorFuture<A, Output = ()> + 'static, [src]

Spawns a future into the context, waiting for it to resolve.

This stops processing any incoming events until the future resolves.

fn waiting(&self) -> bool[src]

Checks if the context is paused (waiting for future completion or stopping).

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

Cancels a spawned future.

The handle is a value returned by the spawn method.

Loading content...

Provided methods

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

Registers a stream with the context.

This allows handling a Stream in a way similar to normal actor messages.

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

#[derive(Message)]
#[rtype(result = "()")]
struct Ping;

struct MyActor;

impl StreamHandler<Ping> for MyActor {

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

    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(async { Ping }));
   }
}

fn main() {
    let mut sys = System::new();
    let addr = sys.block_on(async { MyActor.start() });
    sys.run();
 }

fn add_message_stream<S>(&mut self, fut: S) where
    S: Stream + 'static,
    S::Item: Message,
    A: Handler<S::Item>, [src]

Registers a stream with the context, ignoring errors.

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

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

#[derive(Message)]
#[rtype(result = "()")]
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(async { Ping }));
    }
}

fn main() {
   System::new().block_on(async {
       let addr = MyActor.start();
   });
}

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

Sends the message msg to self. This bypasses the mailbox capacity, and will always queue the message. If the actor is in the stopped state, an error will be raised.

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

Sends the message msg to self after a specified period of time.

Returns a spawn handle which can be used for cancellation. The notification gets cancelled if the context’s stop method gets called. This bypasses the mailbox capacity, and will always queue the message. If the actor is in the stopped state, an error will be raised.

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

Executes a closure after a specified period of time.

The closure gets passed the same actor and its context. Execution gets cancelled if the context’s stop method gets called.

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

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 = Self>, [src]

Loading content...