Struct Context 

pub struct Context<E: Event> { /* private fields */ }

Runtime-provided context for an actor to interact with the system.

Use it to:

• send(event): emit events into the broker tagged with this actor’s name
• stop(): request graceful shutdown of this actor (and trigger global cancel)
• name(): retrieve the actor’s name for logging/identity
• is_alive(): check whether the actor loop should continue running

Correlation:

• send_with_correlation(event, id): emit an event linked to a specific correlation id.
• send_child_event(event, meta): convenience to set correlation id to the parent meta.id().

See also: Envelope, Meta, crate::Supervisor.

Implementations

impl<E: Event> Context<E>

pub fn new( actor_id: ActorId, sender: Sender<Arc<Envelope<E>>>, alive: Arc<AtomicBool>, ) -> Self

pub async fn send(&self, event: E) -> Result<()>

Send an event to the broker. The envelope will carry this actor’s name. This awaits channel capacity (backpressure) to avoid silent drops.

pub async fn send_with_correlation( &self, event: E, correlation_id: EventId, ) -> Result<()>

Send an event with an explicit correlation id.

pub async fn send_child_event(&self, event: E, meta: &Meta) -> Result<()>

Emit a child event correlated to the given parent Meta.

pub async fn send_envelope(&self, envelope: Envelope<E>) -> Result<()>

pub fn stop(&mut self)

Signal this actor to stop

pub fn actor_id(&self) -> &ActorId

pub fn actor_name(&self) -> &str

The actor’s name as registered with the supervisor.

pub fn is_alive(&self) -> bool

Whether the actor is considered alive by the runtime.

pub async fn pending(&self) -> Result<()>

Returns a future that never completes.

Note: This method is largely obsolete. The default step() implementation now returns StepAction::Never, which disables stepping entirely. You only need pending() if you want to block inside a custom step() implementation.

// Prefer this (default behavior):
async fn step(&mut self) -> Result<StepAction> {
    Ok(StepAction::Never)
}

// Or simply don't implement step() at all - it defaults to Never

Trait Implementations

impl<E: Clone + Event> Clone for Context<E>

fn clone(&self) -> Context<E>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.