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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use crate::{node_traits::DynComputedNode, utils::is_value_pointer_equal};

struct CyclicCheckVisitor {
	path_visitor: PathVisitor,
}

impl CyclicCheckVisitor {
	fn new() -> Self {
		Self {
			path_visitor: PathVisitor::new(),
		}
	}

	fn pre(&mut self, node: &'_ DynComputedNode) {
		if self.path_visitor.has_node(node) {
			panic!("Cyclic dependency");
		}
		self.path_visitor.pre(node);
	}

	fn post(&mut self) {
		self.path_visitor.post();
	}
}

struct PathVisitor {
	path: Vec<DynComputedNode>,
}

impl PathVisitor {
	fn new() -> Self {
		Self { path: Vec::new() }
	}

	fn has_node(&self, node: &'_ DynComputedNode) -> bool {
		self.path
			.iter()
			.any(|path_node| is_value_pointer_equal(path_node.as_ptr(), node.as_ptr()))
	}

	fn pre(&mut self, node: &'_ DynComputedNode) {
		self.path.push(node.clone());
	}

	fn post(&mut self) {
		self.path.pop();
	}
}

struct VisitedNodesVisitor {
	visited: Vec<DynComputedNode>,
}

impl VisitedNodesVisitor {
	fn new() -> Self {
		Self {
			visited: Vec::new(),
		}
	}

	fn should_enter(&self, node: &'_ DynComputedNode) -> bool {
		!self.visited.iter().any(|visited_node| {
			is_value_pointer_equal(visited_node.as_ptr(), node.as_ptr())
		})
	}

	fn post(&mut self, node: &'_ DynComputedNode) {
		self.visited.push(node.clone());
	}
}

pub(crate) struct ResolutionVisitor {
	cyclic_visitor: CyclicCheckVisitor,
	visited_nodes_visitor: VisitedNodesVisitor,
	resolved: Vec<DynComputedNode>,
}

impl ResolutionVisitor {
	pub(crate) fn new() -> Self {
		Self {
			cyclic_visitor: CyclicCheckVisitor::new(),
			visited_nodes_visitor: VisitedNodesVisitor::new(),
			resolved: Vec::new(),
		}
	}

	pub(crate) fn should_enter(&self, node: &'_ DynComputedNode) -> bool {
		self.visited_nodes_visitor.should_enter(node)
	}

	pub(crate) fn pre(&mut self, node: &'_ DynComputedNode) {
		self.cyclic_visitor.pre(node);
	}

	pub(crate) fn post(&mut self, node: &'_ DynComputedNode) {
		self.cyclic_visitor.post();
		self.visited_nodes_visitor.post(node);
		self.resolved.push(node.clone());
	}

	pub(crate) fn get_resolved(mut self) -> Vec<DynComputedNode> {
		self.resolved.reverse();
		self.resolved
	}
}