Struct SignalArbiter 

pub struct SignalArbiter { /* private fields */ }

Available on crate feature signals only.

Shared arbiter used to register and dispatch named signals.

Implementations

impl SignalArbiter

pub fn new() -> Self

Creates a new, empty signal arbiter.

pub fn set_global_broadcast_capacity(capacity: usize)

Sets the global broadcast capacity used for topic channels.

This affects all newly created topics across all arbiters.

pub fn global_broadcast_capacity() -> usize

Returns the current global broadcast capacity.

pub fn on<F, Fut>(&self, id: impl Into<String>, handler: F)

where F: Fn(Signal) -> Fut + Send + Sync + 'static, Fut: Future<Output = ()> + Send + 'static,

Registers a handler for the given signal id.

Handlers are invoked in registration order whenever a matching signal is emitted.

pub fn subscribe(&self, id: impl AsRef<str>) -> Receiver<Signal>

Subscribes to a broadcast channel for the given signal id.

This is useful for long-lived listeners such as metrics collectors, background workers, plugins, or middleware driven tasks.

pub fn subscribe_prefix(&self, prefix: impl AsRef<str>) -> Receiver<Signal>

Subscribes to all signals whose id starts with the given prefix.

For example, subscribe_prefix("request.") will receive request.started, request.completed, etc.

pub fn subscribe_all(&self) -> Receiver<Signal>

Subscribes to all signals regardless of their id.

This is a special variant that receives every emitted signal. Internally uses a wildcard prefix matching (empty prefix = all signals).

pub fn subscribe_filtered<F>( &self, id: impl AsRef<str>, filter: F, ) -> SignalStream

where F: Fn(&Signal) -> bool + Send + Sync + 'static,

Subscribes using a filter function on top of an id-based subscription.

This spawns a background task that forwards only matching signals into an unbounded channel, which is returned as a SignalStream.

pub async fn once(&self, id: impl AsRef<str>) -> Option<Signal>

Waits for the next occurrence of a signal id (oneshot-style).

This uses the broadcast channel under the hood but resolves on the first successfully received signal.

pub fn register_rpc<Req, Res, F, Fut>(&self, id: impl Into<String>, f: F)

where Req: Send + Sync + 'static, Res: Send + Sync + 'static, F: Fn(Arc<Req>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Res> + Send + 'static,

Registers a typed RPC handler under the given id.

This allows request/response style interactions over the same arbiter, using type-erased storage internally for flexibility.

pub async fn call_rpc_arc<Req, Res>( &self, id: impl AsRef<str>, req: Req, ) -> Option<Arc<Res>>

where Req: Send + Sync + 'static, Res: Send + Sync + 'static,

Calls a typed RPC handler and returns a shared pointer to the response.

pub async fn call_rpc_result<Req, Res>( &self, id: impl AsRef<str>, req: Req, ) -> RpcResult<Res>

where Req: Send + Sync + 'static, Res: Send + Sync + Clone + 'static,

Calls a typed RPC handler and returns an owned response with an error type.

pub async fn call_rpc<Req, Res>( &self, id: impl AsRef<str>, req: Req, ) -> Option<Res>

where Req: Send + Sync + 'static, Res: Send + Sync + Clone + 'static,

Calls a typed RPC handler and returns an owned response.

pub async fn call_rpc_timeout<Req, Res>( &self, id: impl AsRef<str>, req: Req, dur: Duration, ) -> Result<Res, RpcTimeoutError>

where Req: Send + Sync + 'static, Res: Send + Sync + Clone + 'static,

Calls a typed RPC handler with a timeout.

pub async fn emit(&self, signal: Signal)

Emits a signal and awaits all registered handlers.

Handlers run concurrently and this method resolves once all handlers have completed.

pub async fn emit_app(signal: Signal)

Emits a signal using the global application-level arbiter.

pub fn register_exporter<F>(&self, exporter: F)

where F: Fn(&Signal) + Send + Sync + 'static,

Registers a global exporter that is invoked for every emitted signal.

Exporters are merged when routers are merged, similar to handlers.

pub fn signal_ids(&self) -> Vec<String>

Returns a list of known signal ids (exact topics) currently registered.

pub fn signal_prefixes(&self) -> Vec<String>

Returns a list of known signal prefixes (topics ending with ‘*’).

pub fn rpc_ids(&self) -> Vec<String>

Returns a list of registered RPC ids.

Trait Implementations

impl Clone for SignalArbiter

fn clone(&self) -> SignalArbiter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for SignalArbiter

fn default() -> SignalArbiter

Returns the “default value” for a type.