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
106

use std::cell::Ref;

use crate::{
	connect_node_update::NodeUpdate,
	connect_structs::Connect,
	connect_update::ConnectUpdate,
	node_traits::{AnyDynNode, ConnectNode, NodeValueAccess},
};

pub(crate) trait ConnectNodeUpdateInitiator {
	fn before_get_node(&mut self, node: ConnectNode);

	fn after_set_node(&mut self, node: ConnectNode);

	fn after_set_nodes(&mut self, modified_nodes: Vec<AnyDynNode>);
}

impl ConnectNodeUpdateInitiator for Connect {
	fn before_get_node<'a>(&mut self, node: ConnectNode) {
		self.add_to_current_update_dependencies(&node);
	}

	fn after_set_node<'a>(&mut self, node: ConnectNode) {
		match &mut self.modified_nodes {
			None => {
				self.after_set_nodes(vec![node.into()]);
			}
			Some(modified_nodes) => {
				modified_nodes.push(node.into());
			}
		}
	}

	fn after_set_nodes(&mut self, mut modified_nodes: Vec<AnyDynNode>) {
		let update_list = self.get_update_list(&mut modified_nodes);
		self.recalculate_update_list(&mut modified_nodes, update_list);
	}
}

trait ConnectNodeAccess {
	fn get_concrete_from_node<'a, N: ?Sized, R>(&self, node: &N) -> &'a R;

	fn get_mut_concrete_from_node<'a, N: ?Sized, R>(&self, node: &mut N) -> &'a mut R;
}

impl ConnectNodeAccess for Connect {
	fn get_concrete_from_node<'a, N: ?Sized, R>(&self, node: &N) -> &'a R {
		let node_dyn_ptr: *const N = node;
		let node_ptr = node_dyn_ptr.cast::<R>();
		unsafe {
			if let Some(node_ref) = node_ptr.as_ref() {
				node_ref
			} else {
				unreachable!()
			}
		}
	}

	fn get_mut_concrete_from_node<'a, N: ?Sized, R>(&self, node: &mut N) -> &'a mut R {
		let node_dyn_ptr: *mut N = node;
		let node_ptr = node_dyn_ptr.cast::<R>();
		unsafe {
			if let Some(node_mut) = node_ptr.as_mut() {
				node_mut
			} else {
				unreachable!()
			}
		}
	}
}

pub trait ConnectNodeInterface {
	fn get<'a, T: NodeValueAccess + Into<ConnectNode> + Clone + 'static>(
		&mut self,
		node: &'a T,
	) -> Ref<'a, T::Value>;

	fn set<T: NodeValueAccess + Into<ConnectNode> + Clone + 'static>(
		&mut self,
		node: &'_ T,
		value: T::Value,
	) -> T::Value;
}

impl ConnectNodeInterface for Connect {
	fn get<'a, T: NodeValueAccess + Into<ConnectNode> + Clone + 'static>(
		&mut self,
		node: &'a T,
	) -> Ref<'a, T::Value> {
		self.before_get_node(node.clone().into());
		node.get_inert()
	}

	fn set<T: NodeValueAccess + Into<ConnectNode> + Clone + 'static>(
		&mut self,
		node: &'_ T,
		value: T::Value,
	) -> T::Value {
		let prev_value = node.set_inert(value);
		let is_changed = !node.equal(&prev_value);
		if is_changed {
			self.after_set_node(node.clone().into());
		}
		prev_value
	}
}