A configurable, multi-threaded signals and slots implementation for Rust. Uses mpsc channels and a configurable event-loop-like system internally to allow for fully multi-threaded message handling without wasting cpu time.

Example

use apex::{Signal, Slot};
use std::sync::{ Arc, atomic::{
AtomicBool, AtomicI32, Ordering }
};
use std::time::Duration;

//create a slot that will poll continuously for 10 milliseconds in 10 millisecond intervals
let mut slot = Slot::<i32>::new(Duration::from_millis(10), Duration::from_millis(10));
let mut sig = Signal::<i32>::new();

let multiply = Arc::new(AtomicBool::new(true));
let multiply_cloned = multiply.clone();
let num = Arc::new(AtomicI32::new(5));
let num_cloned = num.clone();

slot.connect(&mut sig);
let callback = move |t: i32| {
if multiply_cloned.load(Ordering::Relaxed) {
let mut temp = num_cloned.load(Ordering::Relaxed);
temp *= t;
num_cloned.store(temp, Ordering::Release);
}
else {
let mut temp = num_cloned.load(Ordering::Relaxed);
temp /= t;
num_cloned.store(temp, Ordering::Relaxed);
}
};
slot.open(callback);

sig.emit(5);
//in practice this would be using some sort of timing synchronization mechanism,
//but this is good enough for this simple test/example to make sure the 'emit' has finished
//before 'assert' gets called
std::thread::sleep(std::time::Duration::from_millis(10));

let multiplied = num.load(Ordering::Relaxed);
assert_eq!(multiplied, 25);
multiply.store(false, Ordering::Relaxed);
//ditto above
std::thread::sleep(std::time::Duration::from_millis(10));

sig.emit(25);
//ditto above
std::thread::sleep(std::time::Duration::from_millis(10));

let divided = num.load(Ordering::Relaxed);
assert_eq!(divided, 1);
slot.close();