Struct LocalHandle

pub struct LocalHandle<A: Actor + Referable> { /* private fields */ }

A lightweight ProcHandle for procs managed in-process via LocalProcManager.

This handle wraps the minimal identifying state of a spawned proc:

• its ProcId (logical identity on the host),
• the proc’s ChannelAddr (the address callers bind into the host router), and
• the ActorRef to the agent actor hosted in the proc.

Unlike external handles, LocalHandle does not manage an OS child process. It provides a uniform surface (proc_id(), addr(), agent_ref()) and implements terminate()/kill() by calling into the underlying Proc::destroy_and_wait, i.e., proc-level shutdown.

Type parameter: A is constrained by the ProcHandle::Agent bound (Actor + Referable).

Trait Implementations

impl<A: Actor + Referable> Clone for LocalHandle<A>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Actor + Referable> Debug for LocalHandle<A>

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

Formats the value using the given formatter.

impl<A: Actor + Referable> ProcHandle for LocalHandle<A>

type Agent = A

Agent = A (inherits Actor + Referable from the trait bound).

fn ready<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ReadyError<Self::TerminalStatus>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Always resolves immediately: a local proc is created in-process and is usable as soon as the handle exists.

fn wait<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Self::TerminalStatus, WaitError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Always resolves immediately with (): a local proc has no external lifecycle to await. There is no OS child process behind this handle.

type TerminalStatus = ()

The type of terminal status produced when the proc exits.

fn proc_id(&self) -> &ProcId

The proc’s logical identity on this host.

fn addr(&self) -> Option<ChannelAddr>

The proc’s address (the one callers bind into the host router).

fn agent_ref(&self) -> Option<ActorRef<Self::Agent>>

The agent actor reference hosted in the proc.

fn terminate<'life0, 'async_trait>( &'life0 self, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), TerminateError<Self::TerminalStatus>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Politely stop the proc before the deadline; managers that own a child OS process may escalate to a forced kill at the deadline. Idempotent and race-safe: concurrent callers coalesce; the first terminal outcome wins and all callers observe it via wait().

fn kill<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), TerminateError<Self::TerminalStatus>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Force the proc down immediately. For in-process managers this may abort actor tasks; for external managers this typically sends SIGKILL. Also idempotent/race-safe; the terminal outcome is the one observed by wait().