refactor: fine-grained interior mutability for scenegraph

src/core/scenegraph.rs

@@ -3,43 +3,45 @@ use crate::nodes::core::Node;
 use anyhow::Result;
 use libstardustxr::scenegraph;
 use libstardustxr::scenegraph::ScenegraphError;
-use rccell::{RcCell, WeakCell};
+use rccell::RcCell;
+use std::cell::RefCell;
 use std::collections::HashMap;
+use std::rc::{Rc, Weak};
+use std::sync::RwLock;
 
+#[derive(Default)]
 pub struct Scenegraph<'a> {
-	client: WeakCell<Client<'a>>,
-	pub nodes: HashMap<String, RcCell<Node<'a>>>,
+	client: RefCell<Weak<Client<'a>>>,
+	pub nodes: RwLock<HashMap<String, RcCell<Node<'a>>>>,
 }
 
 impl<'a> Scenegraph<'a> {
-	pub fn set_client(&mut self, client: RcCell<Client<'a>>) {
-		self.client = client.downgrade();
+	pub fn get_client(&self) -> Rc<Client<'a>> {
+		self.client.borrow().upgrade().unwrap()
 	}
 
-	pub fn add_node(&mut self, node: Node<'a>) -> RcCell<Node<'a>> {
+	pub fn set_client(&self, client: &Rc<Client<'a>>) {
+		*self.client.borrow_mut() = Rc::downgrade(client);
+	}
+
+	pub fn add_node(&self, node: Node<'a>) -> RcCell<Node<'a>> {
 		let path = node.get_path().to_string();
 		let node_rc = RcCell::new(node);
-		self.nodes.insert(path, node_rc.clone());
+		self.nodes.write().unwrap().insert(path, node_rc.clone());
 		node_rc
 	}
-}
 
-impl<'a> Default for Scenegraph<'a> {
-	fn default() -> Self {
-		Scenegraph {
-			client: WeakCell::new(),
-			nodes: HashMap::new(),
-		}
+	pub fn get_node(&self, path: &str) -> Option<RcCell<Node<'a>>> {
+		Some(self.nodes.read().ok()?.get(path)?.clone())
 	}
 }
 
 impl<'a> scenegraph::Scenegraph for Scenegraph<'a> {
 	fn send_signal(&self, path: &str, method: &str, data: &[u8]) -> Result<(), ScenegraphError> {
-		self.nodes
-			.get(path)
+		self.get_node(path)
 			.ok_or(ScenegraphError::NodeNotFound)?
 			.borrow()
-			.send_local_signal(self.client.upgrade().unwrap(), method, data)
+			.send_local_signal(self.get_client(), method, data)
 			.map_err(|_| ScenegraphError::MethodNotFound)
 	}
 	fn execute_method(
@@ -48,11 +50,10 @@ impl<'a> scenegraph::Scenegraph for Scenegraph<'a> {
 		method: &str,
 		data: &[u8],
 	) -> Result<Vec<u8>, ScenegraphError> {
-		self.nodes
-			.get(path)
+		self.get_node(path)
 			.ok_or(ScenegraphError::NodeNotFound)?
 			.borrow()
-			.execute_local_method(self.client.upgrade().unwrap(), method, data)
+			.execute_local_method(self.get_client(), method, data)
 			.map_err(|_| ScenegraphError::MethodNotFound)
 	}
 }