Struct Context 

pub struct Context { /* private fields */ }

The execution context for a process.

A Context is passed to each process and provides access to:

• The process’s own PID
• The process’s mailbox for receiving messages
• Methods for sending messages to other processes
• Methods for creating links and monitors

Examples

async fn my_process(ctx: Context) {
    let my_pid = ctx.pid();

    // Receive a message
    if let Some(envelope) = ctx.recv().await {
        // Handle message
    }

    // Send a message to another process
    ctx.send(other_pid, &MyMessage { data: 42 }).unwrap();
}

Implementations

impl Context

pub fn new( pid: Pid, mailbox: Mailbox, state: Arc<RwLock<ProcessState>>, registry: ProcessRegistry, ) -> Self

Creates a new context for a process.

pub fn pid(&self) -> Pid

Returns this process’s PID.

pub async fn recv(&mut self) -> Option<Vec<u8>>

Receives the next message from the mailbox.

Returns None if the mailbox is closed.

pub async fn recv_timeout( &mut self, timeout: Duration, ) -> Result<Option<Vec<u8>>, ()>

Receives the next message with a timeout.

Returns Ok(Some(data)) if a message was received, Ok(None) if the mailbox was closed, or Err(()) if the timeout elapsed.

pub fn try_recv(&mut self) -> Option<Vec<u8>>

Tries to receive a message without blocking.

pub fn send_raw(&self, pid: Pid, data: Vec<u8>) -> Result<(), SendError>

Sends a raw message to another process.

pub fn send<M: Term>(&self, pid: Pid, msg: &M) -> Result<(), SendError>

Sends a typed message to another process.

pub fn set_trap_exit(&self, trap: bool) -> bool

Sets the trap_exit flag for this process.

When true, exit signals from linked processes are delivered as SystemMessage::Exit messages instead of terminating this process.

Returns the previous value.

pub fn is_trapping_exits(&self) -> bool

Returns whether this process is trapping exits.

pub fn link(&self, other: Pid) -> Result<(), SendError>

Creates a bidirectional link with another process.

If either process terminates abnormally, the other will receive an exit signal.

pub fn unlink(&self, other: Pid)

Removes a link with another process.

pub fn monitor(&self, target: Pid) -> Result<Ref, SendError>

Creates a monitor on another process.

Returns a reference that will be included in the DOWN message when the monitored process terminates.

pub fn demonitor(&self, reference: Ref)

Removes a monitor.

The reference will no longer be valid and no DOWN message will be sent for this monitor.

pub fn exit(&self, target: Pid, reason: ExitReason) -> Result<(), SendError>

Sends an exit signal to another process.

If reason is ExitReason::Killed, the target will terminate unconditionally. Otherwise, the behavior depends on whether the target is trapping exits.

pub fn whereis(&self, name: &str) -> Option<Pid>

Looks up a process by registered name.

pub fn register(&self, name: String) -> bool

Registers a name for this process.

Returns false if the name is already taken.

pub fn unregister(&self, name: &str) -> Option<Pid>

Unregisters a name.

pub fn is_alive(&self, pid: Pid) -> bool

Returns true if the given process is alive.

Trait Implementations

impl Debug for Context

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

Formats the value using the given formatter.