Struct Supervisor 

pub struct Supervisor<E: Event, T: Topic<E> = DefaultTopic> { /* private fields */ }

Coordinates actors and the broker, and owns the top-level runtime.

Actor Registration

// Subscribe to specific topics
supervisor.add_actor("processor", |ctx| Processor::new(ctx), &[MyTopic::Data])?;

// Subscribe to all topics (e.g., monitoring)
supervisor.add_actor("monitor", |ctx| Monitor::new(ctx), Subscribe::all())?;

// Subscribe to no topics (pure event producer)
supervisor.add_actor("producer", |ctx| Producer::new(ctx), Subscribe::none())?;

Runtime Control

• start() spawns the broker loop and returns immediately (non-blocking).
• join() awaits all actor tasks to finish; typically used after start().
• run() combines start() and join(), blocking until shutdown.
• stop() graceful shutdown; lets actors consume active events
• send(event) emits events into the broker.

See also: Actor, Context, Topic.

Implementations

impl<E: Event, T: Topic<E>> Supervisor<E, T>

pub fn new(config: Config) -> Self

Create a new supervisor with the given runtime configuration.

pub fn add_actor<A, F, S>( &mut self, name: &str, factory: F, topics: S, ) -> Result<ActorId>

where A: Actor<Event = E>, F: FnOnce(Context<E>) -> A, S: Into<Subscribe<E, T>>,

Register a new actor with a factory that receives a Context<E>.

This is the primary way to register actors with the supervisor.

Arguments

• name - Actor identifier used for metadata and routing
• factory - Closure that receives a Context and returns the actor
• topics - Slice of topics the actor subscribes to

Example

supervisor.add_actor(
    "processor",
    |ctx| DataProcessor::new(ctx),
    &[MyTopic::Data, MyTopic::Control]
)?;

pub async fn start(&mut self) -> Result<()>

Start the broker loop in a background task. This returns immediately.

pub async fn join(&mut self) -> Result<()>

Waits until at least one of the actor tasks completes then triggers a shutdown if not already requested.

pub async fn run(&mut self) -> Result<()>

Convenience method to start and then await completion of all tasks. Blocks until shutdown.

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

Emit an event into the broker from the supervisor.

pub async fn stop(&mut self) -> Result<()>

Request a graceful shutdown, then await all actor tasks.

Shutdown Process

1. Waits for the broker to receive all pending events (up to 10 ms)
2. Stops the broker and waits for it to drain actor queues
3. Cancels all actors and waits for tasks t

pub fn config(&self) -> &Config

Trait Implementations

impl<E: Event, T: Topic<E>> Default for Supervisor<E, T>

fn default() -> Self

Returns the “default value” for a type.

impl<E: Event, T: Topic<E>> Drop for Supervisor<E, T>

fn drop(&mut self)

Executes the destructor for this type.