Struct actix::Context

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

An actor execution context.

Methods

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

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

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.

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

fn terminate(&mut self)

Terminate actor execution

fn state(&self) -> ActorState

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<Item = (), Error = (), Actor = A> + 'static,

Spawns a future into the context.

fn wait<F>(&mut self, fut: F) where     F: ActorFuture<Item = (), Error = (), Actor = A> + '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, S::Error>,

Registers a stream with the context.

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

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, 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

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

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

Formats the value using the given formatter.