Struct FeagiSignal 

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

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_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_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.