rsconnect 0.2.2

Fine-grained reactivity in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use crate::{
	connect_node_update::NodeUpdate,
	connect_structs::Connect,
	node_traits::{AnyDynNode, ConnectNode, DynComputedNode},
	utils::is_value_pointer_equal,
};

fn is_dependency_equal_modified(dependency: &ConnectNode, modified: &AnyDynNode) -> bool {
	match (dependency, modified) {
		(ConnectNode::Observed(dependency), AnyDynNode::Observed(modified))
		| (ConnectNode::ObservedAny(dependency), AnyDynNode::Observed(modified)) => {
			is_value_pointer_equal(dependency.as_ptr(), modified.as_ptr())
		}
		(ConnectNode::Computed(dependency), AnyDynNode::Computed(modified))
		| (ConnectNode::ComputedAny(dependency), AnyDynNode::Computed(modified))
		| (ConnectNode::Effected(dependency), AnyDynNode::Computed(modified))
		| (ConnectNode::EffectedAny(dependency), AnyDynNode::Computed(modified)) => {
			is_value_pointer_equal(dependency.as_ptr(), modified.as_ptr())
		}
		_ => false,
	}
}

pub(crate) trait ConnectDependencies {
	fn remove_computed_from_derived_lists(&self, computed: &DynComputedNode);

	fn add_computed_to_derived_lists(&self, computed: &DynComputedNode);

	fn recalculate_value_and_set_dependencies(
		&mut self,
		computed: &DynComputedNode,
		modified_nodes: &mut Vec<AnyDynNode>,
	);

	fn is_any_dependency_changed(
		&self,
		computed: &DynComputedNode,
		modified_nodes: &[AnyDynNode],
	) -> bool;
}

impl ConnectDependencies for Connect {
	fn remove_computed_from_derived_lists(&self, computed: &DynComputedNode) {
		let computed_clone = computed.clone();
		let computed_borrow = computed_clone.borrow();
		let dependencies = computed_borrow.get_dependencies();
		for dependency in dependencies {
			self.remove_from_derived(computed, dependency);
		}
	}

	fn add_computed_to_derived_lists(&self, computed: &DynComputedNode) {
		let computed_clone = computed.clone();
		let computed_borrow = computed_clone.borrow();
		let dependencies = computed_borrow.get_dependencies();
		for dependency in dependencies {
			self.add_to_derived(computed, dependency);
		}
	}

	fn recalculate_value_and_set_dependencies(
		&mut self,
		computed: &DynComputedNode,
		modified_nodes: &mut Vec<AnyDynNode>,
	) {
		let (is_changed, dependencies) =
			self.get_computed_value(|c| computed.borrow_mut().recalculate(c));
		computed.borrow_mut().run_effect();
		computed.borrow_mut().set_dependencies(dependencies);
		if is_changed {
			modified_nodes.push(AnyDynNode::Computed(computed.clone()));
		}
	}

	fn is_any_dependency_changed(
		&self,
		computed: &DynComputedNode,
		modified_nodes: &[AnyDynNode],
	) -> bool {
		for dependency in computed.borrow().get_dependencies() {
			if modified_nodes.iter().any(|modified_node| {
				is_dependency_equal_modified(dependency, modified_node)
			}) {
				return true;
			}
		}
		false
	}
}