refactor(method_response): move to foundation

Author: technobaboo

codegen/src/lib.rs

@@ -306,7 +306,7 @@ fn generate_aspect(aspect: &Aspect) -> TokenStream {
 					_node: std::sync::Arc<crate::nodes::Node>,
 					_method: u64,
 					_message: crate::nodes::Message,
-					_method_response: crate::core::scenegraph::MethodResponseSender,
+					_method_response: stardust_xr_server_foundation::MethodResponseSender,
 				) {
 					match _method {
 						#run_methods

foundation/src/lib.rs

@@ -1,8 +1,10 @@
 pub mod delta;
 pub mod error;
-pub mod id;
+mod id;
+mod method_response;
 pub mod registry;
 pub mod resource;
 pub mod task;
 
 pub use id::*;
+pub use method_response::*;

foundation/src/method_response.rs

@@ -0,0 +1,65 @@
+use crate::error::{Result, ServerError};
+use serde::Serialize;
+use stardust_xr_wire::{flex::serialize, messenger::MethodResponse, scenegraph::ScenegraphError};
+use std::os::fd::OwnedFd;
+
+pub struct MethodResponseSender(pub(crate) MethodResponse);
+impl MethodResponseSender {
+	pub fn send_err(self, error: ScenegraphError) {
+		self.0.send(Err(error));
+	}
+	pub fn send<T: Serialize>(self, result: Result<T, ServerError>) {
+		let data = match result {
+			Ok(d) => d,
+			Err(e) => {
+				self.0.send(Err(ScenegraphError::MemberError {
+					error: e.to_string(),
+				}));
+				return;
+			}
+		};
+		let Ok(serialized) = stardust_xr_wire::flex::serialize(data) else {
+			self.0.send(Err(ScenegraphError::MemberError {
+				error: "Internal: Failed to serialize".to_string(),
+			}));
+			return;
+		};
+		self.0.send(Ok((&serialized, Vec::<OwnedFd>::new())));
+	}
+	pub fn wrap<T: Serialize, F: FnOnce() -> Result<T>>(self, f: F) {
+		self.send(f())
+	}
+	pub fn wrap_async<T: Serialize>(
+		self,
+		f: impl Future<Output = Result<(T, Vec<OwnedFd>)>> + Send + 'static,
+	) {
+		tokio::task::spawn(async move {
+			let (value, fds) = match f.await {
+				Ok(d) => d,
+				Err(e) => {
+					self.0.send(Err(ScenegraphError::MemberError {
+						error: e.to_string(),
+					}));
+					return;
+				}
+			};
+			let Ok(serialized) = serialize(value) else {
+				self.0.send(Err(ScenegraphError::MemberError {
+					error: "Internal: Failed to serialize".to_string(),
+				}));
+				return;
+			};
+			self.0.send(Ok((&serialized, fds)));
+		});
+	}
+}
+impl From<MethodResponse> for MethodResponseSender {
+	fn from(response: MethodResponse) -> Self {
+		Self(response)
+	}
+}
+impl std::fmt::Debug for MethodResponseSender {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		f.debug_struct("TypedMethodResponse").finish()
+	}
+}

src/core/scenegraph.rs

@@ -1,15 +1,9 @@
 use crate::{
-	core::{
-		Id,
-		client::Client,
-		error::{Result, ServerError},
-	},
+	core::{Id, client::Client, error::Result},
 	nodes::{Message, Node, alias::get_original},
 };
 use dashmap::DashMap;
-use serde::Serialize;
 use stardust_xr_wire::{
-	flex::serialize,
 	messenger::MethodResponse,
 	scenegraph::{self, ScenegraphError},
 };
@@ -19,62 +13,6 @@ use std::{
 };
 use tracing::{debug, debug_span};
 
-pub struct MethodResponseSender(pub(crate) MethodResponse);
-impl MethodResponseSender {
-	pub fn send_err(self, error: ScenegraphError) {
-		self.0.send(Err(error));
-	}
-	pub fn send<T: Serialize>(self, result: Result<T, ServerError>) {
-		let data = match result {
-			Ok(d) => d,
-			Err(e) => {
-				self.0.send(Err(ScenegraphError::MemberError {
-					error: e.to_string(),
-				}));
-				return;
-			}
-		};
-		let Ok(serialized) = stardust_xr_wire::flex::serialize(data) else {
-			self.0.send(Err(ScenegraphError::MemberError {
-				error: "Internal: Failed to serialize".to_string(),
-			}));
-			return;
-		};
-		self.0.send(Ok((&serialized, Vec::<OwnedFd>::new())));
-	}
-	pub fn wrap<T: Serialize, F: FnOnce() -> Result<T>>(self, f: F) {
-		self.send(f())
-	}
-	pub fn wrap_async<T: Serialize>(
-		self,
-		f: impl Future<Output = Result<(T, Vec<OwnedFd>)>> + Send + 'static,
-	) {
-		tokio::task::spawn(async move {
-			let (value, fds) = match f.await {
-				Ok(d) => d,
-				Err(e) => {
-					self.0.send(Err(ScenegraphError::MemberError {
-						error: e.to_string(),
-					}));
-					return;
-				}
-			};
-			let Ok(serialized) = serialize(value) else {
-				self.0.send(Err(ScenegraphError::MemberError {
-					error: "Internal: Failed to serialize".to_string(),
-				}));
-				return;
-			};
-			self.0.send(Ok((&serialized, fds)));
-		});
-	}
-}
-impl std::fmt::Debug for MethodResponseSender {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		f.debug_struct("TypedMethodResponse").finish()
-	}
-}
-
 #[derive(Default)]
 pub struct Scenegraph {
 	pub(super) client: OnceLock<Weak<Client>>,
@@ -157,7 +95,7 @@ impl scenegraph::Scenegraph for Scenegraph {
 				data: data.to_vec(),
 				fds,
 			},
-			MethodResponseSender(response),
+			response.into(),
 		);
 	}
 }

src/nodes/alias.rs

@@ -1,7 +1,5 @@
 use super::{Aspect, AspectIdentifier, Node};
-use crate::core::{
-	Id, client::Client, error::Result, registry::Registry, scenegraph::MethodResponseSender,
-};
+use crate::core::{Id, MethodResponseSender, client::Client, error::Result, registry::Registry};
 use std::{
 	ops::Add,
 	sync::{Arc, Weak},

src/nodes/items/camera.rs

@@ -7,7 +7,7 @@ use crate::nodes::AspectIdentifier;
 use crate::nodes::items::ITEM_ACCEPTOR_ASPECT_ALIAS_INFO;
 use crate::nodes::items::ITEM_ASPECT_ALIAS_INFO;
 use crate::{
-	core::{client::Client, registry::Registry, scenegraph::MethodResponseSender},
+	core::{MethodResponseSender, client::Client, registry::Registry},
 	nodes::{
 		Message, Node,
 		drawable::model::ModelPart,

src/nodes/mod.rs

@@ -11,7 +11,7 @@ use self::alias::Alias;
 use crate::core::client::Client;
 use crate::core::error::{Result, ServerError};
 use crate::core::registry::Registry;
-use crate::core::{Id, scenegraph::MethodResponseSender};
+use crate::core::{Id, MethodResponseSender};
 use dashmap::DashMap;
 use serde::{Serialize, de::DeserializeOwned};
 use spatial::Spatial;