#![forbid(unsafe_code)]
#![warn(missing_docs)]
#![allow(clippy::type_complexity)]
mod diagnostics;
mod graph;
mod list;
mod nodes;
mod timing;
mod undo;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn var_default_matches_new_of_default() {
let a = Var::<Vec<u32>>::default();
let b = Var::new(Vec::<u32>::new());
assert_eq!(*a.value(), *b.value());
let flag = Var::<bool>::default();
assert!(!*flag.value());
}
}
pub use diagnostics::{DiagnosticEvent, Diagnostics, LogLevel, LogRecord, Logger};
pub use diagnostics::{log, log_debug, log_error, log_info, log_warn};
use graph::{Node, connect, resync_signal_ancestors, write_node};
pub use graph::{Subscription, transaction};
pub use list::{ListChange, ListModel};
use nodes::{
ChangesNode, Combine3Node, Combine4Node, CombineNode, DistinctSignalNode, DistinctStreamNode,
FilterMapStreamNode, FilterStreamNode, FlatMapSwitchNode, FoldStreamNode, MapSignalNode,
MapStreamNode, MergeStreamNode, ObserverNode, SampleStreamNode, SignalSourceNode,
StartWithNode, StreamSourceNode,
};
use std::any::Any;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::thread::JoinHandle;
use std::time::{Duration, Instant};
pub use timing::{ManualTimer, Timer};
pub use undo::{Command, UndoStack};
pub trait Scheduler {
fn schedule(&self, task: Box<dyn FnOnce() + Send>);
fn schedule_fn<F>(&self, f: F)
where
Self: Sized,
F: FnOnce() + Send + 'static,
{
self.schedule(Box::new(f));
}
}
pub struct SyncScheduler;
impl Scheduler for SyncScheduler {
fn schedule(&self, task: Box<dyn FnOnce() + Send>) {
task();
}
}
pub struct QueueScheduler {
queue: Mutex<Vec<Box<dyn FnOnce() + Send>>>,
}
impl QueueScheduler {
pub fn new() -> Self {
Self {
queue: Mutex::new(Vec::new()),
}
}
pub fn pending(&self) -> usize {
self.queue.lock().unwrap().len()
}
pub fn drain(&self) {
let tasks = std::mem::take(&mut *self.queue.lock().unwrap());
for task in tasks {
task();
}
}
}
impl Default for QueueScheduler {
fn default() -> Self {
Self::new()
}
}
impl Scheduler for QueueScheduler {
fn schedule(&self, task: Box<dyn FnOnce() + Send>) {
self.queue.lock().unwrap().push(task);
}
}
pub struct Var<T> {
node: Rc<SignalSourceNode<T>>,
}
impl<T> Clone for Var<T> {
fn clone(&self) -> Self {
Self {
node: self.node.clone(),
}
}
}
impl<T: Default + 'static + PartialEq> Default for Var<T> {
fn default() -> Self {
Self::new(T::default())
}
}
impl<T> Var<T>
where
T: 'static + PartialEq,
{
pub fn new(value: T) -> Self {
Self {
node: Rc::new(SignalSourceNode::new(value)),
}
}
pub fn set(&self, value: T) {
let node: Rc<dyn Node> = self.node.clone();
write_node(node, Rc::new(value));
}
pub fn value(&self) -> Rc<T> {
self.node.value.borrow().clone()
}
pub fn signal(&self) -> Signal<T> {
Signal::new(self.node.clone())
}
}
pub struct Signal<T> {
node: Rc<dyn Node>,
_marker: std::marker::PhantomData<T>,
}
impl<T: 'static> Clone for Signal<T> {
fn clone(&self) -> Self {
Self::new(self.node.clone())
}
}
impl<T> Signal<T>
where
T: 'static,
{
fn new(node: Rc<dyn Node>) -> Self {
Self {
node,
_marker: std::marker::PhantomData,
}
}
pub fn value(&self) -> Rc<T> {
self.node
.current_any()
.expect("signal has a value")
.downcast::<T>()
.expect("signal type mismatch")
}
pub fn observer_count(&self) -> usize {
self.node
.dependents()
.iter()
.filter(|dependent| dependent.is_observer())
.count()
}
pub fn observe<F>(&self, f: F) -> Subscription
where
F: FnMut(&T) + 'static,
{
let callback: Rc<RefCell<dyn FnMut(&T)>> = Rc::new(RefCell::new(f));
self.observe_callback(callback)
}
pub fn observe_with(&self, observer: &Observer<T>) -> Subscription {
self.observe_callback(observer.callback.clone())
}
fn observe_callback(&self, callback: Rc<RefCell<dyn FnMut(&T)>>) -> Subscription {
let node =
Rc::new_cyclic(|weak| ObserverNode::new(self.node.clone(), callback, weak.clone()));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
if let Some(value) = self.node.current_any() {
node.fire(value);
}
Subscription { node: node_any }
}
pub fn map<U, F>(&self, f: F) -> Signal<U>
where
U: 'static + PartialEq,
F: FnMut(&T) -> U + 'static,
{
let node = Rc::new(MapSignalNode::<T, U>::new(self.node.clone(), Box::new(f)));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
node.recompute();
Signal::new(node_any)
}
pub fn distinct(&self) -> Signal<T>
where
T: PartialEq,
{
let node = Rc::new(DistinctSignalNode::<T>::new(self.node.clone()));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
node.recompute();
Signal::new(node_any)
}
pub fn combine<U, R, F>(&self, other: &Signal<U>, f: F) -> Signal<R>
where
U: 'static,
R: 'static + PartialEq,
F: FnMut(&T, &U) -> R + 'static,
{
let node = Rc::new(CombineNode::<T, U, R>::new(
self.node.clone(),
other.node.clone(),
Box::new(f),
));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
connect(other.node.clone(), node_any.clone());
node.recompute();
Signal::new(node_any)
}
pub fn combine3<U, V, R, F>(&self, b: &Signal<U>, c: &Signal<V>, f: F) -> Signal<R>
where
U: 'static,
V: 'static,
R: 'static + PartialEq,
F: FnMut(&T, &U, &V) -> R + 'static,
{
let node = Rc::new(Combine3Node::<T, U, V, R>::new(
self.node.clone(),
b.node.clone(),
c.node.clone(),
Box::new(f),
));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
connect(b.node.clone(), node_any.clone());
connect(c.node.clone(), node_any.clone());
node.recompute();
Signal::new(node_any)
}
pub fn combine4<U, V, W, R, F>(
&self,
b: &Signal<U>,
c: &Signal<V>,
d: &Signal<W>,
f: F,
) -> Signal<R>
where
U: 'static,
V: 'static,
W: 'static,
R: 'static + PartialEq,
F: FnMut(&T, &U, &V, &W) -> R + 'static,
{
let node = Rc::new(Combine4Node::<T, U, V, W, R>::new(
self.node.clone(),
b.node.clone(),
c.node.clone(),
d.node.clone(),
Box::new(f),
));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
connect(b.node.clone(), node_any.clone());
connect(c.node.clone(), node_any.clone());
connect(d.node.clone(), node_any.clone());
node.recompute();
Signal::new(node_any)
}
pub fn changes(&self) -> EventStream<T> {
let node = Rc::new(ChangesNode::<T>::new(self.node.clone()));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
EventStream::new(node_any)
}
}
pub struct Sink<T> {
node: Rc<StreamSourceNode<T>>,
}
impl<T> Clone for Sink<T> {
fn clone(&self) -> Self {
Self {
node: self.node.clone(),
}
}
}
impl<T> Sink<T>
where
T: 'static,
{
pub fn new() -> Self {
Self {
node: Rc::new(StreamSourceNode::new()),
}
}
pub fn send(&self, value: T) {
let node: Rc<dyn Node> = self.node.clone();
write_node(node, Rc::new(value));
}
pub fn stream(&self) -> EventStream<T> {
EventStream::new(self.node.clone())
}
}
impl<T> Default for Sink<T>
where
T: 'static,
{
fn default() -> Self {
Self::new()
}
}
pub struct EventStream<T> {
node: Rc<dyn Node>,
_marker: std::marker::PhantomData<T>,
}
impl<T: 'static> Clone for EventStream<T> {
fn clone(&self) -> Self {
Self::new(self.node.clone())
}
}
impl<T> EventStream<T>
where
T: 'static,
{
fn new(node: Rc<dyn Node>) -> Self {
Self {
node,
_marker: std::marker::PhantomData,
}
}
pub fn observe<F>(&self, f: F) -> Subscription
where
F: FnMut(&T) + 'static,
{
let callback: Rc<RefCell<dyn FnMut(&T)>> = Rc::new(RefCell::new(f));
self.observe_callback(callback)
}
pub fn observe_with(&self, observer: &Observer<T>) -> Subscription {
self.observe_callback(observer.callback.clone())
}
fn observe_callback(&self, callback: Rc<RefCell<dyn FnMut(&T)>>) -> Subscription {
let node =
Rc::new_cyclic(|weak| ObserverNode::new(self.node.clone(), callback, weak.clone()));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
if self.node.is_signal_backed() {
resync_signal_ancestors(&self.node);
if self.node.ever_observed()
&& let Some(value) = self.node.pull_output()
{
node.fire(value);
}
self.node.mark_observed();
}
Subscription { node: node_any }
}
pub fn map<U, F>(&self, f: F) -> EventStream<U>
where
U: 'static,
F: FnMut(&T) -> U + 'static,
{
let node = Rc::new(MapStreamNode::<T, U>::new(self.node.clone(), Box::new(f)));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
EventStream::new(node_any)
}
pub fn filter<F>(&self, f: F) -> EventStream<T>
where
F: FnMut(&T) -> bool + 'static,
{
let node = Rc::new(FilterStreamNode::<T>::new(self.node.clone(), Box::new(f)));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
EventStream::new(node_any)
}
pub fn filter_map<U, F>(&self, f: F) -> EventStream<U>
where
U: 'static,
F: FnMut(&T) -> Option<U> + 'static,
{
let node = Rc::new(FilterMapStreamNode::<T, U>::new(
self.node.clone(),
Box::new(f),
));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
EventStream::new(node_any)
}
pub fn fold<U, F>(&self, init: U, f: F) -> EventStream<U>
where
U: 'static,
F: FnMut(&U, &T) -> U + 'static,
{
let node = Rc::new(FoldStreamNode::<T, U>::new(init, Box::new(f)));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
EventStream::new(node_any)
}
pub fn distinct(&self) -> EventStream<T>
where
T: PartialEq,
{
let node = Rc::new(DistinctStreamNode::<T>::new(self.node.clone()));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
EventStream::new(node_any)
}
pub fn merge(&self, other: &EventStream<T>) -> EventStream<T> {
Self::merge_all(vec![self.clone(), other.clone()])
}
pub fn merge_all(streams: Vec<EventStream<T>>) -> EventStream<T> {
assert!(
!streams.is_empty(),
"merge_all requires at least one stream"
);
let node = Rc::new(MergeStreamNode::<T>::new());
let node_any: Rc<dyn Node> = node.clone();
for stream in streams {
connect(stream.node.clone(), node_any.clone());
}
EventStream::new(node_any)
}
pub fn sample<S>(&self, signal: &Signal<S>) -> EventStream<S>
where
S: 'static,
{
let node = Rc::new(SampleStreamNode::<T, S>::new(&signal.node));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
EventStream::new(node_any)
}
pub fn start_with(&self, initial: T) -> Signal<T>
where
T: PartialEq,
{
let node = Rc::new(StartWithNode::new(initial));
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
Signal::new(node_any)
}
pub fn flat_map_switch<U, F>(&self, mut f: F) -> EventStream<U>
where
U: 'static,
F: FnMut(&T) -> EventStream<U> + 'static,
{
let node = Rc::new_cyclic(|weak| {
FlatMapSwitchNode::<T, U>::new(
Box::new(move |value: &T| f(value).node.clone()),
weak.clone(),
)
});
let node_any: Rc<dyn Node> = node.clone();
connect(self.node.clone(), node_any.clone());
EventStream::new(node_any)
}
}
pub struct Observer<T> {
callback: Rc<RefCell<dyn FnMut(&T)>>,
}
impl<T> Observer<T> {
pub fn new<F>(f: F) -> Self
where
F: FnMut(&T) + 'static,
{
Self {
callback: Rc::new(RefCell::new(f)),
}
}
pub fn on_next(&self, value: &T) {
(self.callback.borrow_mut())(value);
}
}
impl Subscription {
pub fn owned_by(self, owner: &mut Owner) {
owner.add(self);
}
}
pub struct Owner {
subscriptions: Vec<Subscription>,
}
impl Owner {
pub fn new() -> Self {
Self {
subscriptions: Vec::new(),
}
}
pub fn add(&mut self, subscription: Subscription) {
self.subscriptions.push(subscription);
}
pub fn track(&mut self, subscription: Subscription) -> &mut Self {
self.subscriptions.push(subscription);
self
}
pub fn clear(&mut self) {
self.subscriptions.clear();
}
}
impl Default for Owner {
fn default() -> Self {
Self::new()
}
}
impl Drop for Owner {
fn drop(&mut self) {
self.subscriptions.clear();
}
}
#[derive(Clone)]
pub struct CancellationToken(Arc<AtomicBool>);
impl CancellationToken {
pub fn new() -> Self {
Self(Arc::new(AtomicBool::new(false)))
}
pub fn cancel(&self) {
self.0.store(true, Ordering::Relaxed);
}
pub fn is_cancelled(&self) -> bool {
self.0.load(Ordering::Relaxed)
}
}
impl Default for CancellationToken {
fn default() -> Self {
Self::new()
}
}
type DeliverySlot = Box<dyn FnMut(Box<dyn Any + Send>)>;
thread_local! {
static DELIVERY_SLOTS: RefCell<HashMap<u64, DeliverySlot>> = RefCell::new(HashMap::new());
}
pub struct Task<T> {
id: u64,
token: CancellationToken,
sink: Rc<Sink<T>>,
handle: RefCell<Option<JoinHandle<()>>>,
}
impl<T> Task<T>
where
T: 'static,
{
pub fn cancel(&self) {
self.token.cancel();
}
pub fn is_cancelled(&self) -> bool {
self.token.is_cancelled()
}
pub fn results(&self) -> EventStream<T> {
self.sink.stream()
}
}
impl<T> Drop for Task<T> {
fn drop(&mut self) {
DELIVERY_SLOTS.with(|slots| {
slots.borrow_mut().remove(&self.id);
});
self.token.cancel();
self.handle.borrow_mut().take();
}
}
pub fn spawn_task<F, T>(scheduler: Arc<dyn Scheduler + Send + Sync>, f: F) -> Task<T>
where
T: 'static + Send,
F: FnOnce(&CancellationToken) -> T + Send + 'static,
{
static NEXT_TASK_ID: AtomicU64 = AtomicU64::new(1);
let id = NEXT_TASK_ID.fetch_add(1, Ordering::Relaxed);
let sink = Rc::new(Sink::new());
let slot: DeliverySlot = {
let sink = sink.clone();
Box::new(move |value: Box<dyn Any + Send>| {
let value = value.downcast::<T>().expect("task result type mismatch");
sink.send(*value);
})
};
DELIVERY_SLOTS.with(|slots| {
slots.borrow_mut().insert(id, slot);
});
let token = CancellationToken::new();
let worker_token = token.clone();
let handle = std::thread::spawn(move || {
let value = f(&worker_token);
if worker_token.is_cancelled() {
return;
}
scheduler.schedule(Box::new(move || {
let value: Box<dyn Any + Send> = Box::new(value);
DELIVERY_SLOTS.with(|slots| {
if let Some(mut slot) = slots.borrow_mut().remove(&id) {
slot(value);
}
});
}));
});
Task {
id,
token,
sink,
handle: RefCell::new(Some(handle)),
}
}
pub struct Interval<T> {
id: u64,
token: CancellationToken,
stop: Arc<AtomicBool>,
sink: Rc<Sink<T>>,
handle: RefCell<Option<JoinHandle<()>>>,
}
impl<T> Interval<T>
where
T: 'static,
{
pub fn stop(&self) {
self.stop.store(true, Ordering::Relaxed);
self.token.cancel();
}
pub fn results(&self) -> EventStream<T> {
self.sink.stream()
}
}
impl<T> Drop for Interval<T> {
fn drop(&mut self) {
self.stop.store(true, Ordering::Relaxed);
self.token.cancel();
DELIVERY_SLOTS.with(|slots| {
slots.borrow_mut().remove(&self.id);
});
self.handle.borrow_mut().take();
}
}
pub fn spawn_interval<F, T>(
scheduler: Arc<dyn Scheduler + Send + Sync>,
interval: Duration,
mut f: F,
) -> Interval<T>
where
T: 'static + Send,
F: FnMut(&CancellationToken) -> T + Send + 'static,
{
static NEXT_INTERVAL_ID: AtomicU64 = AtomicU64::new(1);
let id = NEXT_INTERVAL_ID.fetch_add(1, Ordering::Relaxed);
let sink = Rc::new(Sink::new());
let slot: DeliverySlot = {
let sink = sink.clone();
Box::new(move |value: Box<dyn Any + Send>| {
let value = value
.downcast::<T>()
.expect("interval sample type mismatch");
sink.send(*value);
})
};
DELIVERY_SLOTS.with(|slots| {
slots.borrow_mut().insert(id, slot);
});
let token = CancellationToken::new();
let worker_token = token.clone();
let stop = Arc::new(AtomicBool::new(false));
let worker_stop = stop.clone();
let pending = Arc::new(AtomicUsize::new(0));
let handle = std::thread::spawn(move || {
loop {
if worker_stop.load(Ordering::Relaxed) || worker_token.is_cancelled() {
break;
}
let value = f(&worker_token);
if worker_token.is_cancelled() {
break;
}
if pending.load(Ordering::Relaxed) == 0 {
pending.store(1, Ordering::Relaxed);
let pending = pending.clone();
let id = id;
scheduler.schedule(Box::new(move || {
let value: Box<dyn Any + Send> = Box::new(value);
DELIVERY_SLOTS.with(|slots| {
if let Some(slot) = slots.borrow_mut().get_mut(&id) {
slot(value);
}
});
pending.store(0, Ordering::Relaxed);
}));
}
let deadline = Instant::now() + interval;
while Instant::now() < deadline {
if worker_stop.load(Ordering::Relaxed) {
break;
}
std::thread::sleep(Duration::from_millis(20));
}
}
DELIVERY_SLOTS.with(|slots| {
slots.borrow_mut().remove(&id);
});
});
Interval {
id,
token,
stop,
sink,
handle: RefCell::new(Some(handle)),
}
}