1use std::{
3 cell::{Cell, RefCell},
4 rc::{Rc, Weak},
5};
6
7thread_local! {
8 static EVALUATING: RefCell<Option<Rc<DependencyNode>>> = const { RefCell::new(None) };
9}
10
11#[derive(Default)]
12struct DependencyNode {
13 dirty: Cell<bool>,
14 evaluating: Cell<bool>,
15 sources: RefCell<Vec<Weak<Self>>>,
16 dependents: RefCell<Vec<Weak<Self>>>,
17}
18
19impl DependencyNode {
20 fn track(self: &Rc<Self>) {
21 EVALUATING.with(|current| {
22 let current = current.borrow();
23 let Some(binding) = current.as_ref() else {
24 return;
25 };
26 if Rc::ptr_eq(self, binding) {
27 return;
28 }
29 let mut sources = binding.sources.borrow_mut();
30 let source = Rc::downgrade(self);
31 if !sources.iter().any(|existing| existing.ptr_eq(&source)) {
32 sources.push(source);
33 self.dependents.borrow_mut().push(Rc::downgrade(binding));
34 }
35 });
36 }
37
38 fn detach(&self) {
39 let address = self as *const Self;
40 for source in self.sources.take() {
41 if let Some(source) = source.upgrade() {
42 source
43 .dependents
44 .borrow_mut()
45 .retain(|binding| binding.as_ptr() != address);
46 }
47 }
48 }
49
50 fn push_dependents(&self, pending: &mut Vec<Rc<Self>>) {
51 self.dependents.borrow_mut().retain(|weak| {
52 if let Some(binding) = weak.upgrade() {
53 pending.push(binding);
54 true
55 } else {
56 false
57 }
58 });
59 }
60
61 fn notify(&self) {
62 let mut pending = Vec::new();
63 self.push_dependents(&mut pending);
64 while let Some(binding) = pending.pop() {
65 if !binding.dirty.replace(true) {
66 binding.push_dependents(&mut pending);
67 }
68 }
69 }
70
71 fn evaluate<T>(self: &Rc<Self>, binding: impl FnOnce() -> T) -> T {
72 self.detach();
73 self.evaluating.set(true);
74 self.dirty.set(false);
75 let mut evaluation = Evaluation {
76 node: self,
77 previous: EVALUATING.with(|current| current.replace(Some(self.clone()))),
78 completed: false,
79 };
80 let value = binding();
81 evaluation.completed = true;
82 value
83 }
84}
85
86impl Drop for DependencyNode {
87 fn drop(&mut self) {
88 self.detach();
89 self.notify();
90 }
91}
92
93struct Evaluation<'a> {
94 node: &'a DependencyNode,
95 previous: Option<Rc<DependencyNode>>,
96 completed: bool,
97}
98
99impl Drop for Evaluation<'_> {
100 fn drop(&mut self) {
101 EVALUATING.with(|current| current.replace(self.previous.take()));
102 self.node.evaluating.set(false);
103 if !self.completed && !self.node.dirty.replace(true) {
104 self.node.notify();
105 }
106 }
107}
108
109#[derive(Default)]
111pub struct ChangeSignal(Rc<DependencyNode>);
112
113impl ChangeSignal {
114 pub(crate) fn is_tracking() -> bool {
115 EVALUATING.with(|current| current.borrow().is_some())
116 }
117
118 pub(crate) fn has_dependents(&self) -> bool {
119 !self.0.dependents.borrow().is_empty()
120 }
121
122 pub fn track(&self) {
123 self.0.track();
124 }
125
126 pub fn notify(&self) {
127 self.0.notify();
128 }
129}
130
131enum Stored<T> {
132 Unset,
133 Explicit(T),
134 Cached(T),
135}
136
137pub struct Property<T> {
141 value: RefCell<Stored<T>>,
142 binding: Option<Box<dyn Fn() -> T>>,
143 dependency: Rc<DependencyNode>,
144}
145
146impl<T> Default for Property<T> {
147 fn default() -> Self {
148 Self::new(None)
149 }
150}
151
152impl<T> Property<T> {
153 pub fn new(binding: Option<Box<dyn Fn() -> T>>) -> Self {
154 Self {
155 value: RefCell::new(Stored::Unset),
156 binding,
157 dependency: Rc::default(),
158 }
159 }
160
161 pub fn set(&self, value: T) {
162 self.replace(Stored::Explicit(value), true);
163 }
164
165 pub fn is_dirty(&self) -> bool {
167 self.dependency.dirty.get()
168 }
169
170 pub(crate) fn matches_current(&self, predicate: impl FnOnce(&T) -> bool) -> bool {
172 match &*self.value.borrow() {
173 Stored::Explicit(value) => predicate(value),
174 Stored::Cached(value) if !self.dependency.dirty.get() => predicate(value),
175 _ => false,
176 }
177 }
178
179 pub fn reset(&self) {
180 if matches!(*self.value.borrow(), Stored::Explicit(_)) {
181 self.replace(Stored::Unset, true);
182 }
183 }
184
185 fn replace(&self, value: Stored<T>, changed: bool) {
186 let previous = self.value.replace(value);
187 self.dependency.detach();
188 self.dependency.dirty.set(true);
189 if changed {
190 self.dependency.notify();
191 }
192 drop(previous);
193 }
194}
195
196impl<T: PartialEq> Property<T> {
197 pub fn set_if_changed(&self, value: T) {
199 let changed = match &*self.value.borrow() {
200 Stored::Explicit(current) => {
201 if *current == value {
202 return;
203 }
204 true
205 }
206 Stored::Cached(current) if !self.dependency.dirty.get() => *current != value,
207 Stored::Unset | Stored::Cached(_) => true,
208 };
209 self.replace(Stored::Explicit(value), changed);
210 }
211}
212
213impl<T: Clone> Property<T> {
214 pub fn explicit_value(&self) -> Option<T> {
216 self.dependency.track();
217 match &*self.value.borrow() {
218 Stored::Explicit(value) => Some(value.clone()),
219 _ => None,
220 }
221 }
222
223 pub fn get(&self, default: impl FnOnce() -> T) -> T {
224 assert!(
225 !self.dependency.evaluating.get(),
226 "cyclic property evaluation"
227 );
228 self.dependency.track();
229 match &*self.value.borrow() {
230 Stored::Explicit(value) => return value.clone(),
231 Stored::Cached(value) if !self.dependency.dirty.get() => return value.clone(),
232 Stored::Unset | Stored::Cached(_) => {}
233 }
234
235 let value = self.dependency.evaluate(|| match &self.binding {
236 Some(binding) => binding(),
237 None => default(),
238 });
239 if !self.dependency.dirty.get() {
240 let cached = value.clone();
241 if !self.dependency.dirty.get() {
242 self.value.replace(Stored::Cached(cached));
243 }
244 }
245 value
246 }
247}
248
249#[doc(hidden)]
252pub enum InputProperty<T> {
253 Local(Property<T>),
254 Linked {
255 read: Box<dyn Fn() -> Option<T>>,
256 write: Box<dyn Fn(T)>,
257 },
258 State {
259 value: Property<T>,
260 read: Box<dyn Fn() -> Option<T>>,
261 base: Box<Self>,
262 },
263}
264
265impl<T> Default for InputProperty<T> {
266 fn default() -> Self {
267 Self::Local(Property::default())
268 }
269}
270
271impl<T> InputProperty<T> {
272 pub fn bound(read: impl Fn() -> T + 'static) -> Self {
273 Self::Local(Property::new(Some(Box::new(read))))
274 }
275
276 pub fn linked(read: impl Fn() -> Option<T> + 'static, write: impl Fn(T) + 'static) -> Self {
277 Self::Linked {
278 read: Box::new(read),
279 write: Box::new(write),
280 }
281 }
282
283 pub fn with_state(self, read: impl Fn() -> Option<T> + 'static) -> Self {
286 Self::State {
287 value: Property::default(),
288 read: Box::new(read),
289 base: Box::new(self),
290 }
291 }
292
293 pub fn reset(&self) {
294 match self {
295 Self::Local(value) | Self::State { value, .. } => value.reset(),
296 Self::Linked { .. } => {}
297 }
298 }
299}
300
301impl<T: Clone> InputProperty<T> {
302 pub fn get(&self, default: impl FnOnce() -> T) -> T {
303 match self {
304 Self::Local(property) => property.get(default),
305 Self::Linked { read, .. } => read().unwrap_or_else(default),
306 Self::State { value, read, base } => {
307 value.get(|| read().unwrap_or_else(|| base.get(default)))
308 }
309 }
310 }
311}
312
313impl<T: PartialEq> InputProperty<T> {
314 pub fn set_if_changed(&self, value: T) {
315 match self {
316 Self::Local(property)
317 | Self::State {
318 value: property, ..
319 } => property.set_if_changed(value),
320 Self::Linked { write, .. } => write(value),
321 }
322 }
323}
324
325#[cfg(test)]
326mod tests {
327 use super::*;
328 use std::panic::{AssertUnwindSafe, catch_unwind};
329
330 #[test]
331 fn state_input_restores_the_live_fallback_after_reset() {
332 let active = Rc::new(Property::default());
333 active.set(true);
334 let base = Property::default();
335 base.set(1);
336 let state = active.clone();
337 let input = InputProperty::default().with_state(move || state.get(|| false).then_some(2));
338 let read = || input.get(|| base.get(|| 0));
339
340 assert_eq!(read(), 2);
341 input.set_if_changed(2);
342 active.set(false);
343 base.set(3);
344 assert_eq!(read(), 2);
345 input.reset();
346 assert_eq!(read(), 3);
347 active.set(true);
348 assert_eq!(read(), 2);
349 }
350
351 #[test]
352 fn invalidation_reaches_a_diamond_once() {
353 let source = Property::default();
354 let left = Property::default();
355 let right = Property::default();
356 let total = Property::default();
357 let evaluations = Cell::new(0);
358
359 source.set(1);
360 let value = || {
361 total.get(|| {
362 evaluations.set(evaluations.get() + 1);
363 let left = left.get(|| source.get(|| 0) + source.get(|| 0));
364 left + right.get(|| source.get(|| 0) * 3)
365 })
366 };
367 assert_eq!(value(), 5);
368 source.set(2);
369 source.set(3);
370 assert_eq!(evaluations.get(), 1);
371 assert_eq!(value(), 15);
372 assert_eq!(value(), 15);
373 assert_eq!(evaluations.get(), 2);
374 }
375
376 #[test]
377 fn unwinding_a_nested_evaluation_allows_retry_and_restores_tracking() {
378 let source = Property::default();
379 let inner = Property::default();
380 let outer = Property::default();
381 let first = Cell::new(true);
382 source.set(7);
383
384 let value = || {
385 outer.get(|| {
386 catch_unwind(AssertUnwindSafe(|| {
387 inner.get(|| {
388 let number = source.get(|| 0);
389 assert!(!first.replace(false), "transient failure");
390 number
391 })
392 }))
393 .unwrap_or(0)
394 })
395 };
396 assert_eq!(value(), 0);
397 assert_eq!(value(), 7);
398 source.set(9);
399 assert_eq!(value(), 9);
400 }
401
402 #[test]
403 fn invalidation_during_evaluation_does_not_cache_an_obsolete_result() {
404 let source = Property::default();
405 let derived = Property::default();
406 source.set(1);
407
408 assert_eq!(
409 derived.get(|| {
410 let previous = source.get(|| 0);
411 source.set(2);
412 previous
413 }),
414 1
415 );
416 assert_eq!(derived.get(|| source.get(|| 0)), 2);
417 assert_eq!(derived.get(|| panic!("cache should be valid")), 2);
418 }
419
420 #[test]
421 fn dropping_a_source_invalidates_bindings_that_read_through_weak_references() {
422 let source = Rc::new(Property::default());
423 source.set(8);
424 let weak = Rc::downgrade(&source);
425 let derived = Property::default();
426 let value = || derived.get(|| weak.upgrade().map_or(0, |source| source.get(|| 0)));
427 assert_eq!(value(), 8);
428 drop(source);
429 assert_eq!(value(), 0);
430 }
431}