Struct FeagiSignal 

pub struct FeagiSignal<T> { /* private fields */ }

Event signal system similar to Godot signals.

Allows subscribing callbacks that will be invoked when events are emitted. Uses FnMut to allow closures to capture and modify external state via Arc<Mutex<T>>.

Example with Shared State

use std::sync::{Arc, Mutex};
use feagi_data_structures::FeagiSignal;
 
struct MyHandler {
    count: i32,
}
 
impl MyHandler {
    fn handle_event(&mut self, data: &String) {
        self.count += 1;
        println!("Event {}: {}", self.count, data);
    }
}
 
let handler = Arc::new(Mutex::new(MyHandler { count: 0 }));
let mut signal = FeagiSignal::new();
 
// Clone Arc for the closure
let handler_clone = Arc::clone(&handler);
signal.connect(move |data| {
    handler_clone.lock().unwrap().handle_event(data);
});
 
signal.emit(&"Hello".to_string());
assert_eq!(handler.lock().unwrap().count, 1);

Implementations

impl<T> FeagiSignal<T>

pub fn new() -> Self

Creates a new empty signal.

pub fn connect<F>(&mut self, f: F) -> FeagiSignalIndex

where F: FnMut(&T) + Send + 'static,

Connects a callback to this signal.

The callback will be invoked whenever emit() is called. Returns a handle that can be used to disconnect later.

Example

use feagi_data_structures::FeagiSignal;
 
let mut signal = FeagiSignal::new();
let handle = signal.connect(|value: &i32| {
    println!("Received: {}", value);
});
 
signal.emit(&42);
signal.disconnect(handle).unwrap();

pub fn disconnect( &mut self, index: FeagiSignalIndex, ) -> Result<(), FeagiDataError>

Disconnects a previously connected callback.

Returns an error if no callback with the given index exists.

pub fn emit(&mut self, value: &T)

Emits an event to all connected callbacks.

Callbacks are invoked in arbitrary order.

pub fn connect_with_shared_state<S, F>( &mut self, state: Arc<Mutex<S>>, callback: F, ) -> FeagiSignalIndex

where S: Send + 'static, F: FnMut(&mut S, &T) + Send + 'static,

Helper to connect a closure that captures an Arc<Mutex<S>>.

This is a convenience method for the common pattern of calling methods on shared mutable state from within the callback.

Example

use std::sync::{Arc, Mutex};
use feagi_data_structures::FeagiSignal;
 
struct Counter { value: i32 }
impl Counter {
    fn increment(&mut self) { self.value += 1; }
}
 
let counter = Arc::new(Mutex::new(Counter { value: 0 }));
let mut signal = FeagiSignal::new();
 
signal.connect_with_shared_state(
    Arc::clone(&counter),
    |state, _event| state.increment()
);
 
signal.emit(&"event");
assert_eq!(counter.lock().unwrap().value, 1);

pub fn listener_count(&self) -> usize

Returns the number of connected listeners.

pub fn disconnect_all(&mut self)

Removes all connected listeners.

Trait Implementations

impl<T> Debug for FeagiSignal<T>

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

Formats the value using the given formatter.

impl<T> Default for FeagiSignal<T>

fn default() -> Self

Returns the “default value” for a type.