Reuse next node info

Author: oovm

projects/syntax-tree/src/inner_node/mod.rs

@@ -0,0 +1,95 @@
+use core::fmt::{Debug, Formatter};
+use std::num::NonZeroUsize;
+
+#[derive(Clone)]
+pub struct StorageNode<M> {
+    pub(crate) parent: Option<usize>,
+    pub(crate) previous: Option<NonZeroUsize>,
+    pub(crate) next: Option<NonZeroUsize>,
+    pub(crate) children: Option<ChildLink>,
+    pub(crate) data: Option<M>,
+}
+
+#[derive(Copy, Clone)]
+pub struct ChildLink {
+    first: NonZeroUsize,
+    last: NonZeroUsize,
+}
+
+
+impl<M> StorageNode<M> {
+    pub fn empty() -> Self {
+        Self {
+            parent: None,
+            previous: None,
+            next: None,
+            children: None,
+            data: None,
+        }
+    }
+    pub fn new(data: M) -> Self {
+        Self {
+            parent: None,
+            previous: None,
+            next: None,
+            children: None,
+            data: Some(data),
+        }
+    }
+    pub fn make_child(&mut self, new: usize) -> Option<NonZeroUsize> {
+        debug_assert_ne!(new, 0, "Root node can't be child");
+        let new = unsafe {
+            NonZeroUsize::new_unchecked(new)
+        };
+        match &mut self.children {
+            Some(s) => {
+                let old = s.last;
+                s.last = new;
+                Some(old)
+            }
+            None => {
+                self.children = Some(ChildLink {
+                    first: new,
+                    last: new,
+                });
+                None
+            }
+        }
+    }
+}
+
+impl ChildLink {
+    pub unsafe fn new(first: usize) -> Self {
+        Self {
+            first: NonZeroUsize::new_unchecked(first),
+            last: NonZeroUsize::new_unchecked(first),
+        }
+    }
+}
+
+impl<M: Debug> Debug for StorageNode<M> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        let kind = if self.data.is_none() {
+            "Placeholder"
+        } else if self.children.is_none() {
+            "Leaf"
+        } else {
+            "Node"
+        };
+        let fmt = &mut f.debug_struct(kind);
+        match &self.parent {
+            Some(s) => {
+                fmt.field("parent", s)
+            }
+            None => {
+                fmt.field("parent", &Option::<()>::None)
+            }
+        };
+
+        if let Some(s) = &self.data {
+            fmt.field("data", s);
+        }
+
+        fmt.finish()
+    }
+}

projects/syntax-tree/src/lib.rs

@@ -5,10 +5,11 @@
 #![doc(html_logo_url = "https://raw.githubusercontent.com/oovm/shape-rs/dev/projects/images/Trapezohedron.svg")]
 #![doc(html_favicon_url = "https://raw.githubusercontent.com/oovm/shape-rs/dev/projects/images/Trapezohedron.svg")]
 
-extern crate alloc;
-extern crate core;
 extern crate core;
+extern crate alloc;
 
 mod errors;
 mod syntax_tree;
-mod syntax_node;
+mod inner_node;
+
+pub use syntax_tree::{SyntaxTree, SyntaxNode};

projects/syntax-tree/src/syntax_node/mod.rs

@@ -2,11 +2,19 @@ use alloc::vec::Vec;
 use core::fmt::{Debug, Formatter};
 use core::num::NonZeroUsize;
 use std::collections::BTreeMap;
+use crate::inner_node::{ChildLink, StorageNode};
 
 
 type NodeID = usize;
 
+/// A node in the syntax tree.
+#[derive(Copy, Clone, Debug)]
+pub struct SyntaxNode<M> {
+    pub node: NodeID,
+    pub data: M,
+}
 
+#[derive(Clone)]
 pub struct SyntaxTree<M> {
     store: Vec<StorageNode<M>>,
     first_empty: Option<NonZeroUsize>,
@@ -36,10 +44,7 @@ impl<M> SyntaxTree<M> {
     }
     pub fn create_root(&mut self, data: M) -> NodeID {
         self.store.clear();
-        self.store.push(StorageNode::Root {
-            children: None,
-            data,
-        });
+        self.store.push(StorageNode::new(data));
         0
     }
     pub fn create_place_holder(&mut self) -> NodeID {
@@ -49,52 +54,35 @@ impl<M> SyntaxTree<M> {
                 let new_id = s.get();
                 debug_assert!(self.store.get(new_id).is_some());
                 unsafe {
-                    match self.store.get_unchecked_mut(new_id) {
-                        StorageNode::Empty { next_empty, is_placeholder } => {
-                            self.first_empty = *next_empty;
-                            *is_placeholder = true
-                        }
-                        _ => {
-                            unreachable!("Node {s} is not empty")
-                        }
-                    }
+                    let hole = self.store.get_unchecked_mut(new_id);
+                    debug_assert!(hole.data.is_none());
+                    // hole.next = s;
                 }
                 new_id
             }
             // no remaining holes
             None => {
-                self.store.push(StorageNode::Empty { is_placeholder: true, next_empty: None });
+                self.store.push(StorageNode::empty());
                 self.store.len().saturating_sub(1)
             }
         }
     }
 
     unsafe fn insert_node(&mut self, id: usize, data: M) {
         let node = self.store.get_unchecked_mut(id);
-        *node = StorageNode::Node {
-            parent: None,
-            previous: None,
-            next: None,
-            children: None,
-            data,
-        };
+        *node = StorageNode::new(data);
     }
 
     pub fn update_node(&mut self, node: SyntaxNode<M>) {
         match self.store.get_mut(node.node) {
-            Some(StorageNode::Root { data, .. }) => {
-                *data = node.data;
-            }
-            Some(StorageNode::Node { data, .. }) => {
-                *data = node.data;
+            Some(s) => {
+                s.data = Some(node.data);
             }
-            Some(StorageNode::Empty { next_empty, is_placeholder: _ }) => {
-                self.first_empty = *next_empty;
-                unsafe {
-                    self.insert_node(node.node, node.data)
+            None => {
+                if cfg!(debug_assertions) {
+                    panic!("Node {} does not exist", node.node);
                 }
             }
-            None => {}
         }
     }
     pub fn create_node(&mut self, data: M) -> NodeID {
@@ -103,42 +91,22 @@ impl<M> SyntaxTree<M> {
         node
     }
 
-    fn mark_empty(&mut self, node: NodeID) {
-        self.store.insert(node, StorageNode::Empty { is_placeholder: false, next_empty: self.first_empty })
-    }
-
     /// remove a single node
     pub fn delete_node(&mut self, node: NodeID) {
         match self.store.get_mut(node) {
-            Some(StorageNode::Root { children, data }) => {}
-            Some(StorageNode::Node { parent, previous, next, children, data }) => {}
-            Some(StorageNode::Empty { is_placeholder, next_empty }) => {}
+            Some(s) => {}
             None => {}
         }
         self.delete_node(node)
     }
-    pub fn make_parent(&mut self, parent: NodeID, child: NodeID) {
-        debug_assert!(child != 0, "Root node cannot be its own child");
+    pub unsafe fn make_parent_unchecked(&mut self, parent: NodeID, child: NodeID) {
         match self.store.get_mut(parent) {
-            Some(StorageNode::Root { children, data }) => {
-                match children {
-                    Some(s) => {
-                        s.last = unsafe {
-                            ChildLink::new(child)
-                        }
-                    }
-                    None => {
-                        unsafe {
-                            ChildLink::new(child)
-                        }
-                    }
-                }
+            Some(s) => {
+                todo!()
             }
-            Some(StorageNode::Node { parent, previous, next, children, data }) => {}
-            Some(StorageNode::Empty { is_placeholder, .. }) => {
-                panic!("Cannot make empty node {parent} as parent of {child}")
+            None => {
+                panic!("Cannot make node {parent} as parent of {child}")
             }
-            None => {}
         }
     }