implement serialize through intermediate representation

Author: LoZack19

src/serde.rs

@@ -1,82 +1,48 @@
-use std::num::NonZeroUsize;
+use serde::ser::{Serialize, SerializeStruct};
 
-use serde::{Deserialize, Serialize};
+use crate::{NodeRef, Tree};
 
-use crate::{Node, NodeId, Tree};
-
-impl<T: Serialize> Serialize for Tree<T> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        self.vec.serialize(serializer)
-    }
+#[derive(Debug)]
+struct SerNode<'a, T> {
+    value: &'a T,
+    children: Vec<SerNode<'a, T>>,
 }
 
-impl<'de, T: Deserialize<'de>> Deserialize<'de> for Tree<T> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let vec = Vec::deserialize(deserializer)?;
-        Ok(Tree { vec })
+impl<'a, T> From<NodeRef<'a, T>> for SerNode<'a, T> {
+    fn from(node: NodeRef<'a, T>) -> Self {
+        let value: &T = node.value();
+        let children: Vec<SerNode<'a, T>> = node.children().map(SerNode::<'a, T>::from).collect();
+        SerNode { value, children }
     }
 }
 
-impl<T: Serialize> Serialize for Node<T> {
+impl<'a, T: Serialize> Serialize for SerNode<'a, T> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
-        (
-            &self.parent,
-            &self.prev_sibling,
-            &self.next_sibling,
-            &self.children,
-            &self.value,
-        )
-            .serialize(serializer)
+        (&self.value, &self.children).serialize(serializer)
     }
 }
 
-impl<'de, T: Deserialize<'de>> Deserialize<'de> for Node<T> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let (parent, prev_sibling, next_sibling, children, value) =
-            <(
-                Option<NodeId>,
-                Option<NodeId>,
-                Option<NodeId>,
-                Option<(NodeId, NodeId)>,
-                T,
-            )>::deserialize(deserializer)?;
-        Ok(Node {
-            parent,
-            prev_sibling,
-            next_sibling,
-            children,
-            value,
-        })
-    }
-}
-
-impl Serialize for NodeId {
+impl<T: Serialize> Serialize for Tree<T> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
-        self.0.serialize(serializer)
+        SerNode::from(self.root()).serialize(serializer)
     }
 }
 
-impl<'de> Deserialize<'de> for NodeId {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let index = <NonZeroUsize>::deserialize(deserializer)?;
-        Ok(NodeId(index))
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::tree;
+
+    #[test]
+    fn test_ser_node_from() {
+        let tree = tree!("a" => {"b", "c" => {"d", "e"}, "f"});
+        let repr = serde_json::to_string(&SerNode::from(tree.root())).unwrap();
+        println!("{repr}");
     }
 }

tests/serde.rs

@@ -8,7 +8,4 @@ fn test_serialize() {
 
     let serialized = serde_json::to_string(&tree).unwrap();
     println!("{serialized}");
-    let deserialized: Tree<&str> = serde_json::from_str(&serialized).unwrap();
-
-    assert_eq!(tree, deserialized);
 }