Struct actix_web::actix::dev::Context

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

Actor execution context

Implementations

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

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

pub fn handle(&self) -> SpawnHandle

Handle of the running future

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

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

Set mailbox capacity

By default mailbox capacity is 16 messages.

Trait Implementations

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

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 = Context<A>>,

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

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

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

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.

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

Return Address of the context

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

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

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

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

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

Send message msg to self.

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

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) -> SpawnHandlewhere
    F: 'static + FnOnce(&mut A, &mut <A as Actor>::Context),

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) -> SpawnHandlewhere
    F: 'static + FnMut(&mut A, &mut <A as Actor>::Context),

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 = Context<A>>,

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

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

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

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: 'static + Message + Send,
    <M as Message>::Result: Send,

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

Pack message into suitable envelope