session_rust/
treenode.rs

1use crate::tree::Tree;
2use serde::{ser::Serialize as SerTrait, Deserialize, Serialize};
3use std::cell::RefCell;
4use std::fmt;
5use std::rc::{Rc, Weak};
6use uuid::Uuid;
7
8// Internal type alias to hide complexity
9type NodeRef = Rc<RefCell<TreeNodeInner>>;
10type WeakNodeRef = Weak<RefCell<TreeNodeInner>>;
11
12#[derive(Debug, Clone)]
13struct TreeNodeInner {
14    pub guid: String,
15    pub name: String,
16    children: Vec<NodeRef>,
17    parent: Option<WeakNodeRef>,
18    tree: Option<Weak<RefCell<Tree>>>,
19}
20
21/// TreeNode with a clean, simple API
22#[derive(Debug, Clone)]
23pub struct TreeNode {
24    inner: NodeRef,
25}
26
27impl PartialEq for TreeNode {
28    fn eq(&self, other: &Self) -> bool {
29        Rc::ptr_eq(&self.inner, &other.inner)
30    }
31}
32
33impl Serialize for TreeNode {
34    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
35    where
36        S: serde::Serializer,
37    {
38        self.to_serde().serialize(serializer)
39    }
40}
41
42impl<'de> Deserialize<'de> for TreeNode {
43    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
44    where
45        D: serde::Deserializer<'de>,
46    {
47        let serde_repr = TreeNodeSerde::deserialize(deserializer)?;
48        Ok(Self::from_serde(serde_repr))
49    }
50}
51
52#[derive(Serialize, Deserialize)]
53#[serde(tag = "type", rename = "TreeNode")]
54pub(crate) struct TreeNodeSerde {
55    pub guid: String,
56    pub name: String,
57    pub children: Vec<TreeNodeSerde>,
58}
59
60impl TreeNode {
61    pub fn new(name: &str) -> Self {
62        Self {
63            inner: Rc::new(RefCell::new(TreeNodeInner {
64                guid: Uuid::new_v4().to_string(),
65                name: name.to_string(),
66                children: Vec::new(),
67                parent: None,
68                tree: None,
69            })),
70        }
71    }
72
73    pub fn name(&self) -> String {
74        self.inner.borrow().name.clone()
75    }
76
77    pub fn guid(&self) -> String {
78        self.inner.borrow().guid.clone()
79    }
80
81    pub fn add(&self, child: &TreeNode) {
82        child.inner.borrow_mut().parent = Some(Rc::downgrade(&self.inner));
83        child.inner.borrow_mut().tree = self.inner.borrow().tree.clone();
84        self.inner.borrow_mut().children.push(child.inner.clone());
85    }
86
87    pub fn remove(&self, child: &TreeNode) -> bool {
88        let child_guid = child.guid();
89        let mut inner = self.inner.borrow_mut();
90        if let Some(pos) = inner
91            .children
92            .iter()
93            .position(|c| c.borrow().guid == child_guid)
94        {
95            let removed = inner.children.remove(pos);
96            removed.borrow_mut().parent = None;
97            true
98        } else {
99            false
100        }
101    }
102
103    pub fn parent(&self) -> Option<TreeNode> {
104        self.inner
105            .borrow()
106            .parent
107            .as_ref()?
108            .upgrade()
109            .map(|inner| TreeNode { inner })
110    }
111
112    pub fn children(&self) -> Vec<TreeNode> {
113        self.inner
114            .borrow()
115            .children
116            .iter()
117            .map(|child| TreeNode {
118                inner: Rc::clone(child),
119            })
120            .collect()
121    }
122
123    pub fn is_root(&self) -> bool {
124        self.inner.borrow().parent.is_none()
125    }
126
127    pub fn is_leaf(&self) -> bool {
128        self.inner.borrow().children.is_empty()
129    }
130
131    pub fn ancestors(&self) -> Vec<TreeNode> {
132        let mut result = Vec::new();
133        let mut current = self.parent();
134
135        while let Some(node) = current {
136            result.push(node.clone());
137            current = node.parent();
138        }
139
140        result
141    }
142
143    pub fn descendants(&self) -> Vec<TreeNode> {
144        let mut result = Vec::new();
145        for child in self.children() {
146            result.push(child.clone());
147            result.extend(child.descendants());
148        }
149        result
150    }
151
152    pub fn nodes(&self) -> Vec<TreeNode> {
153        let mut result = vec![self.clone()];
154        for child in self.children() {
155            result.extend(child.nodes());
156        }
157        result
158    }
159
160    pub fn root(&self) -> TreeNode {
161        if let Some(parent) = self.parent() {
162            parent.root()
163        } else {
164            self.clone()
165        }
166    }
167
168    pub fn traverse(&self, strategy: &str, order: &str) -> Vec<TreeNode> {
169        match strategy {
170            "depthfirst" => self.depth_first_traverse(order),
171            "breadthfirst" => self.breadth_first_traverse(),
172            _ => vec![],
173        }
174    }
175
176    fn depth_first_traverse(&self, order: &str) -> Vec<TreeNode> {
177        match order {
178            "preorder" => self.preorder_traverse(),
179            "postorder" => self.postorder_traverse(),
180            _ => vec![],
181        }
182    }
183
184    fn preorder_traverse(&self) -> Vec<TreeNode> {
185        let mut result = vec![self.clone()];
186        for child in self.children() {
187            result.extend(child.preorder_traverse());
188        }
189        result
190    }
191
192    fn postorder_traverse(&self) -> Vec<TreeNode> {
193        let mut result = Vec::new();
194        for child in self.children() {
195            result.extend(child.postorder_traverse());
196        }
197        result.push(self.clone());
198        result
199    }
200
201    fn breadth_first_traverse(&self) -> Vec<TreeNode> {
202        let mut result = Vec::new();
203        let mut queue = Vec::new();
204
205        queue.push(self.clone());
206
207        while let Some(node) = queue.pop() {
208            result.push(node.clone());
209            for child in node.children() {
210                queue.insert(0, child);
211            }
212        }
213
214        result
215    }
216
217    pub fn jsondump(&self) -> Result<String, Box<dyn std::error::Error>> {
218        let serde_node = self.to_serde();
219        let mut buf = Vec::new();
220        let formatter = serde_json::ser::PrettyFormatter::with_indent(b"    ");
221        let mut ser = serde_json::Serializer::with_formatter(&mut buf, formatter);
222        SerTrait::serialize(&serde_node, &mut ser)?;
223        Ok(String::from_utf8(buf)?)
224    }
225
226    pub fn jsonload(json_data: &str) -> Result<Self, Box<dyn std::error::Error>> {
227        let serde_node: TreeNodeSerde = serde_json::from_str(json_data)?;
228        Ok(Self::from_serde(serde_node))
229    }
230
231    pub(crate) fn to_serde(&self) -> TreeNodeSerde {
232        let inner = self.inner.borrow();
233        TreeNodeSerde {
234            guid: inner.guid.clone(),
235            name: inner.name.clone(),
236            children: inner
237                .children
238                .iter()
239                .map(|child| {
240                    TreeNode {
241                        inner: Rc::clone(child),
242                    }
243                    .to_serde()
244                })
245                .collect(),
246        }
247    }
248
249    pub(crate) fn from_serde(serde_node: TreeNodeSerde) -> Self {
250        let node = TreeNode::new(&serde_node.name);
251        node.inner.borrow_mut().guid = serde_node.guid;
252
253        for child_serde in serde_node.children {
254            let child = Self::from_serde(child_serde);
255            node.add(&child);
256        }
257
258        node
259    }
260}
261
262impl fmt::Display for TreeNode {
263    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
264        let inner = self.inner.borrow();
265        write!(
266            f,
267            "TreeNode({}, {}, {} children)",
268            inner.name,
269            inner.guid,
270            inner.children.len()
271        )
272    }
273}
274
275#[cfg(test)]
276#[path = "treenode_test.rs"]
277mod treenode_test;
session_rust/treenode.rs

session_rust/
treenode.rs
