Struct actix::prelude::Context

pub struct Context<A> where
    A: Actor<Context = Context<A>>,  { /* fields omitted */ }

An actor execution context.

Implementations

impl<A> Context<A> where
    A: Actor<Context = Self>, 

pub fn new() -> Self

Create a context without spawning it.

The context can be spawned into an actor using its run method.

struct Actor1 {
    actor2_addr: Addr<Actor2>,
}

struct Actor2 {
    actor1_addr: Addr<Actor1>,
}

let ctx1 = Context::<Actor1>::new();
let ctx2 = Context::<Actor2>::new();

let actor1 = Actor1 { actor2_addr: ctx2.address() };
let actor2 = Actor2 { actor1_addr: ctx1.address() };

ctx1.run(actor1);
ctx2.run(actor2);

pub fn with_receiver(rx: AddressReceiver<A>) -> Self

pub fn run(self, act: A) -> Addr<A>

pub fn into_future(self, act: A) -> ContextFut<A, Self>

pub fn handle(&self) -> SpawnHandle

Returns a handle to the running future.

This is the handle returned by the AsyncContext::spawn() method.

pub fn set_mailbox_capacity(&mut self, cap: usize)

Sets the mailbox capacity.

The default mailbox capacity is 16 messages. #Examples

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

    fn started(&mut self, ctx: &mut Self::Context) {
        ctx.set_mailbox_capacity(1);
        System::current().stop();
    }
}

let addr = sys.block_on(async { MyActor.start() });
sys.run();

pub fn connected(&self) -> bool

Returns whether any addresses are still connected.

Trait Implementations

impl<A> ActorContext for Context<A> where
    A: Actor<Context = Self>, 

fn stop(&mut self)

Immediately stop processing incoming messages and switch to a stopping state. This only affects actors that are currently running. Future attempts to queue messages will fail.

fn terminate(&mut self)

Terminate actor execution unconditionally. This sets the actor into the stopped state. This causes future attempts to queue messages to fail.

fn state(&self) -> ActorState

Retrieve the current Actor execution state.

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

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

Spawns a future into the context.

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

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

fn waiting(&self) -> bool

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

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

Cancels a spawned future.

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

Returns the address of the context.

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

Registers a stream with the context.

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

Registers a stream with the context, ignoring errors.

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

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, 

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

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

Executes a closure after a specified period of time.

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

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

impl<A> AsyncContextParts<A> for Context<A> where
    A: Actor<Context = Self>, 

fn parts(&mut self) -> &mut ContextParts<A>

impl<A: Actor<Context = Context<A>>> Debug for Context<A>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A, M> ToEnvelope<A, M> for Context<A> where
    A: Actor<Context = Context<A>> + Handler<M>,
    M: Message + Send + 'static,
    M::Result: Send, 

fn pack(msg: M, tx: Option<Sender<M::Result>>) -> Envelope<A>

Pack message into suitable envelope