Struct Signal 

pub struct Signal<T>
where
    T: Send + Sync + 'static,
{ /* private fields */ }

Available on crate feature core and non-WebAssembly only.

A signal that can dispatch events to connected receivers

Implementations

impl<T> Signal<T>

where T: Send + Sync + 'static,

pub fn new(name: SignalName) -> Signal<T>

Available on crate feature signals only.

Create a new signal with a type-safe name

Examples

use reinhardt_core::signals::{Signal, SignalName};

// Use built-in signal names
let signal = Signal::<String>::new(SignalName::PRE_SAVE);

// Use custom signal names
let custom = Signal::<String>::new(SignalName::custom("my_signal"));

pub fn metrics(&self) -> SignalMetrics

Available on crate feature signals only.

Get the current metrics for this signal

pub fn reset_metrics(&self)

Available on crate feature signals only.

Reset metrics for this signal

pub fn add_middleware<M>(&self, middleware: M)

where M: SignalMiddleware<T> + 'static,

Available on crate feature signals only.

Add middleware to this signal

pub fn context(&self) -> &SignalContext

Available on crate feature signals only.

Get the signal context

pub fn connect_with_options<F, Fut>( &self, receiver: F, sender_type_id: Option<TypeId>, dispatch_uid: Option<String>, priority: i32, )

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

Available on crate feature signals only.

Connect a receiver function to this signal with full options

Arguments

• receiver - The receiver function to connect
• sender_type_id - Optional TypeId to filter by sender type
• dispatch_uid - Optional unique identifier to prevent duplicate registration
• priority - Execution priority (higher values execute first, default: 0)

pub fn connect_with_full_options<F, Fut, P>( &self, receiver: F, sender_type_id: Option<TypeId>, dispatch_uid: Option<String>, priority: i32, predicate: Option<P>, )

where F: Fn(Arc<T>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), SignalError>> + Send + 'static, P: Fn(&T) -> bool + Send + Sync + 'static,

Available on crate feature signals only.

Connect a receiver with all available options including predicate

Arguments

• receiver - The receiver function to connect
• sender_type_id - Optional TypeId to filter by sender type
• dispatch_uid - Optional unique identifier to prevent duplicate registration
• priority - Execution priority (higher values execute first, default: 0)
• predicate - Optional condition that must be true for receiver to execute

pub fn connect<F, Fut>(&self, receiver: F)

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

Available on crate feature signals only.

Connect a receiver function to this signal (simple version)

pub fn connect_with_priority<F, Fut>(&self, receiver: F, priority: i32)

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

Available on crate feature signals only.

Connect a receiver with priority

pub fn chain(&self, next: &Signal<T>)

where T: Clone,

Available on crate feature signals only.

Chain this signal to another signal When this signal is sent, it will also trigger the chained signal

Example

let signal_a = Signal::<User>::new(SignalName::custom("user_created"));
let signal_b = Signal::<User>::new(SignalName::custom("user_notified"));

signal_a.chain(&signal_b);

// Now sending signal_a will also trigger signal_b
signal_a.send(user).await?;

pub fn chain_with<U, F>(&self, next: &Signal<U>, transform: F)

where U: Send + Sync + 'static, F: Fn(Arc<T>) -> U + Send + Sync + 'static,

Available on crate feature signals only.

Chain this signal to another signal with transformation Allows transforming the instance before passing to the next signal

Example

signal_a.chain_with(&signal_b, |user| {
    // Transform User to NotificationPayload
    NotificationPayload::from(user)
});

pub fn merge(signals: Vec<&Signal<T>>) -> Signal<T>

where T: Clone,

Available on crate feature signals only.

Merge multiple signals into one Returns a new signal that triggers when any of the source signals trigger

Example

let merged = Signal::merge(vec![&signal_a, &signal_b, &signal_c]);

merged.connect(|instance| async move {
    println!("Any of the three signals was triggered!");
    Ok(())
});

pub fn filter<P>(&self, predicate: P) -> Signal<T>

where P: Fn(&T) -> bool + Send + Sync + 'static, T: Clone,

Available on crate feature signals only.

Filter signal emissions based on a predicate Returns a new signal that only triggers when the predicate returns true

Example

let admin_only = user_signal.filter(|user| user.is_admin);

admin_only.connect(|admin_user| async move {
    println!("Admin user action!");
    Ok(())
});

pub fn map<U, F>(&self, transform: F) -> Signal<U>

where U: Send + Sync + 'static, F: Fn(Arc<T>) -> U + Send + Sync + 'static,

Available on crate feature signals only.

Transform signal values Returns a new signal with transformed values

Example

let user_ids = user_signal.map(|user| user.id);

user_ids.connect(|id| async move {
    println!("User ID: {}", id);
    Ok(())
});

pub fn connect_if<F, Fut, P>(&self, receiver: F, predicate: P)

where F: Fn(Arc<T>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), SignalError>> + Send + 'static, P: Fn(&T) -> bool + Send + Sync + 'static,

Available on crate feature signals only.

Connect a receiver with a predicate condition

The receiver will only execute if the predicate returns true for the instance

pub fn disconnect(&self, dispatch_uid: &str) -> bool

Available on crate feature signals only.

Disconnect a receiver by dispatch_uid

pub async fn send_with_sender( &self, instance: T, sender_type_id: Option<TypeId>, ) -> Result<(), SignalError>

Available on crate feature signals only.

Send signal to all connected receivers

Arguments

• instance - The instance to send
• sender_type_id - Optional TypeId of the sender for filtering

pub async fn send(&self, instance: T) -> Result<(), SignalError>

Available on crate feature signals only.

Send signal to all connected receivers (simple version)

pub async fn send_robust( &self, instance: T, sender_type_id: Option<TypeId>, ) -> Vec<Result<(), SignalError>>

Available on crate feature signals only.

Send signal robustly, catching errors

pub fn send_async(&self, instance: T)

Available on crate feature signals only.

Send signal asynchronously (fire and forget)

pub fn receiver_count(&self) -> usize

Available on crate feature signals only.

Get number of connected receivers

pub fn disconnect_all(&self)

Available on crate feature signals only.

Clear all receivers

Trait Implementations

impl<T> AsyncSignalDispatcher<T> for Signal<T>

where T: Send + Sync + 'static,

fn send<'life0, 'async_trait>( &'life0 self, instance: T, ) -> Pin<Box<dyn Future<Output = Result<(), SignalError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Signal<T>: 'async_trait,

Send signal to all connected receivers

fn send_with_sender<'life0, 'async_trait>( &'life0 self, instance: T, sender_type_id: Option<TypeId>, ) -> Pin<Box<dyn Future<Output = Result<(), SignalError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Signal<T>: 'async_trait,

Send signal with sender type filtering

fn send_robust<'life0, 'async_trait>( &'life0 self, instance: T, sender_type_id: Option<TypeId>, ) -> Pin<Box<dyn Future<Output = Vec<Result<(), SignalError>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Signal<T>: 'async_trait,

Send signal robustly, catching errors

impl<T> Clone for Signal<T>

where T: Send + Sync + 'static,

fn clone(&self) -> Signal<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Signal<T>

where T: Send + Sync + 'static,

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

Formats the value using the given formatter.

impl<T> InjectableSignal<T> for Signal<T>

where T: Send + Sync + 'static,

fn connect_with_context<F, Fut>(&self, receiver: F)

where F: Fn(Arc<T>, ReceiverContext) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<(), SignalError>> + Send + 'static,

Connect a receiver function that receives a ReceiverContext

impl<T> SignalDispatcher<T> for Signal<T>

where T: Send + Sync + 'static,

fn receiver_count(&self) -> usize

Get the number of connected receivers

fn disconnect_all(&self)

Clear all receivers

fn disconnect(&self, dispatch_uid: &str) -> bool

Disconnect a receiver by dispatch_uid