Store Input for Monitor Nodes (#1454)

* Add input storage to monitor_node

* Return input via serialize function

node-graph/gcore/src/memo.rs

@@ -45,32 +45,48 @@ impl<T, CachedNode> MemoNode<T, CachedNode> {
 	}
 }
 
+#[derive(Clone)]
+pub struct IORecord<I, O> {
+	pub input: I,
+	pub output: O,
+}
+
 #[cfg(feature = "alloc")]
 /// Caches the output of the last graph evaluation for introspection
 #[derive(Default)]
-pub struct MonitorNode<T> {
-	output: Cell<Option<Arc<T>>>,
+pub struct MonitorNode<I, T, N> {
+	io: Cell<Option<Arc<IORecord<I, T>>>>,
+	node: N,
 }
 
 #[cfg(feature = "alloc")]
-impl<'i, T: 'static + Clone> Node<'i, T> for MonitorNode<T> {
-	type Output = T;
-	fn eval(&'i self, input: T) -> Self::Output {
-		self.output.set(Some(Arc::new(input.clone())));
-		input
+impl<'i, 'a: 'i, T, I, N> Node<'i, I> for MonitorNode<I, T, N>
+where
+	I: Clone + 'static,
+	<N as Node<'i, I>>::Output: Future<Output = T>,
+	T: Clone + 'static,
+	N: Node<'i, I>,
+{
+	type Output = Pin<Box<dyn Future<Output = T> + 'i>>;
+	fn eval(&'i self, input: I) -> Self::Output {
+		Box::pin(async move {
+			let output = self.node.eval(input.clone()).await;
+			self.io.set(Some(Arc::new(IORecord { input, output: output.clone() })));
+			output
+		})
 	}
 
 	fn serialize(&self) -> Option<Arc<dyn core::any::Any>> {
-		let out = self.output.take();
-		self.output.set(out.clone());
-		(out).as_ref().map(|output| output.clone() as Arc<dyn core::any::Any>)
+		let io = self.io.take();
+		self.io.set(io.clone());
+		(io).as_ref().map(|output| output.clone() as Arc<dyn core::any::Any>)
 	}
 }
 
 #[cfg(feature = "alloc")]
-impl<T> MonitorNode<T> {
-	pub const fn new() -> MonitorNode<T> {
-		MonitorNode { output: Cell::new(None) }
+impl<I, T, N> MonitorNode<I, T, N> {
+	pub const fn new(node: N) -> MonitorNode<I, T, N> {
+		MonitorNode { io: Cell::new(None), node }
 	}
 }