Struct meio::Context

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

Context of a ActorRuntime that contains Address and Receiver.

Implementations

impl<A: Actor> Context<A>

pub fn address(&mut self) -> &mut Address<A>

Returns an instance of the Address.

pub fn spawn_actor<T>(&mut self, actor: T, group: A::GroupBy) -> Address<T> where
    T: Actor + StartedBy<A> + InterruptedBy<A>,
    A: Eliminated<T>, 

Starts and binds an Actor.

pub fn spawn_task<T, M>(
    &mut self,
    task: T,
    tag: M,
    group: A::GroupBy
) -> TaskAddress<T> where
    T: LiteTask,
    A: TaskEliminated<T, M>,
    M: Tag, 

Starts and binds a Task.

pub fn attach<S, M>(&mut self, stream: S, tag: M, group: A::GroupBy) where
    S: Stream + Unpin + Send + 'static,
    S::Item: Send,
    A: Consumer<S::Item>,
    M: Tag, 

Spawns interaction task that forwards the result of an interaction.

pub fn track_interaction<I, M>(
    &mut self,
    task: InteractionTask<I>,
    tag: M,
    group: A::GroupBy
) where
    I: Interaction,
    A: InteractionDone<I, M>,
    M: Tag, 

Spawns InteractionTask as a LiteTask and await the result as an Action that will call InteractionDone handler.

pub fn interrupt<T>(&mut self, address: &mut Address<T>) -> Result<(), Error> where
    T: Actor + InterruptedBy<A>, 

Interrupts an Actor.

pub fn not_terminating(&self) -> Result<(), Error>

Returns Error if the Actor is terminating. Useful for checking in handlers.

pub fn stop(&mut self)

Stops the runtime of the Actor on one message will be processed after this call.

It’s recommended way to terminate Actor is the shutdown method.

Attention! Termination process will never started here and all spawned actors and tasks will be orphaned.

pub fn shutdown(&mut self)

Starts graceful termination of the Actor.

pub fn terminate_group(&mut self, group: A::GroupBy)

Sends interruption signal to the sepcific group of actors and tasks.

pub fn is_terminating(&self) -> bool

Returns true if the shutdown process is in progress.

pub fn termination_sequence(&mut self, sequence: Vec<A::GroupBy>)

Increases the priority of the Actor’s type.