session_rust/
tree.rs

1use serde::{ser::Serialize as SerTrait, Deserialize, Serialize};
2use std::cell::RefCell;
3use std::fmt;
4use std::fs;
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: Uuid,
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
33#[derive(Serialize, Deserialize)]
34#[serde(tag = "type", rename = "TreeNode")]
35struct TreeNodeSerde {
36    guid: Uuid,
37    name: String,
38    children: Vec<TreeNodeSerde>,
39}
40
41impl TreeNode {
42    pub fn new(name: &str) -> Self {
43        Self {
44            inner: Rc::new(RefCell::new(TreeNodeInner {
45                guid: Uuid::new_v4(),
46                name: name.to_string(),
47                children: Vec::new(),
48                parent: None,
49                tree: None,
50            })),
51        }
52    }
53
54    pub fn name(&self) -> String {
55        self.inner.borrow().name.clone()
56    }
57
58    pub fn guid(&self) -> Uuid {
59        self.inner.borrow().guid
60    }
61
62    pub fn add(&self, child: &TreeNode) {
63        child.inner.borrow_mut().parent = Some(Rc::downgrade(&self.inner));
64        child.inner.borrow_mut().tree = self.inner.borrow().tree.clone();
65        self.inner.borrow_mut().children.push(child.inner.clone());
66    }
67
68    pub fn remove(&self, child: &TreeNode) -> bool {
69        let child_guid = child.guid();
70        let mut inner = self.inner.borrow_mut();
71        if let Some(pos) = inner
72            .children
73            .iter()
74            .position(|c| c.borrow().guid == child_guid)
75        {
76            let removed = inner.children.remove(pos);
77            removed.borrow_mut().parent = None;
78            true
79        } else {
80            false
81        }
82    }
83
84    pub fn parent(&self) -> Option<TreeNode> {
85        self.inner
86            .borrow()
87            .parent
88            .as_ref()?
89            .upgrade()
90            .map(|inner| TreeNode { inner })
91    }
92
93    pub fn children(&self) -> Vec<TreeNode> {
94        self.inner
95            .borrow()
96            .children
97            .iter()
98            .map(|child| TreeNode {
99                inner: Rc::clone(child),
100            })
101            .collect()
102    }
103
104    pub fn is_root(&self) -> bool {
105        self.inner.borrow().parent.is_none()
106    }
107
108    pub fn is_leaf(&self) -> bool {
109        self.inner.borrow().children.is_empty()
110    }
111
112    pub fn ancestors(&self) -> Vec<TreeNode> {
113        let mut result = Vec::new();
114        let mut current = self.parent();
115
116        while let Some(node) = current {
117            result.push(node.clone());
118            current = node.parent();
119        }
120
121        result
122    }
123
124    pub fn descendants(&self) -> Vec<TreeNode> {
125        let mut result = Vec::new();
126        for child in self.children() {
127            result.push(child.clone());
128            result.extend(child.descendants());
129        }
130        result
131    }
132
133    pub fn nodes(&self) -> Vec<TreeNode> {
134        let mut result = vec![self.clone()];
135        for child in self.children() {
136            result.extend(child.nodes());
137        }
138        result
139    }
140
141    pub fn root(&self) -> TreeNode {
142        if let Some(parent) = self.parent() {
143            parent.root()
144        } else {
145            self.clone()
146        }
147    }
148
149    pub fn traverse(&self, strategy: &str, order: &str) -> Vec<TreeNode> {
150        match strategy {
151            "depthfirst" => self.depth_first_traverse(order),
152            "breadthfirst" => self.breadth_first_traverse(),
153            _ => vec![],
154        }
155    }
156
157    fn depth_first_traverse(&self, order: &str) -> Vec<TreeNode> {
158        match order {
159            "preorder" => self.preorder_traverse(),
160            "postorder" => self.postorder_traverse(),
161            _ => vec![],
162        }
163    }
164
165    fn preorder_traverse(&self) -> Vec<TreeNode> {
166        let mut result = vec![self.clone()];
167        for child in self.children() {
168            result.extend(child.preorder_traverse());
169        }
170        result
171    }
172
173    fn postorder_traverse(&self) -> Vec<TreeNode> {
174        let mut result = Vec::new();
175        for child in self.children() {
176            result.extend(child.postorder_traverse());
177        }
178        result.push(self.clone());
179        result
180    }
181
182    fn breadth_first_traverse(&self) -> Vec<TreeNode> {
183        let mut result = Vec::new();
184        let mut queue = Vec::new();
185
186        queue.push(self.clone());
187
188        while let Some(node) = queue.pop() {
189            result.push(node.clone());
190            for child in node.children() {
191                queue.insert(0, child);
192            }
193        }
194
195        result
196    }
197
198    pub fn to_json_data(&self) -> Result<String, Box<dyn std::error::Error>> {
199        let serde_node = self.to_serde();
200        let mut buf = Vec::new();
201        let formatter = serde_json::ser::PrettyFormatter::with_indent(b"    ");
202        let mut ser = serde_json::Serializer::with_formatter(&mut buf, formatter);
203        SerTrait::serialize(&serde_node, &mut ser)?;
204        Ok(String::from_utf8(buf)?)
205    }
206
207    pub fn from_json_data(json_data: &str) -> Result<Self, Box<dyn std::error::Error>> {
208        let serde_node: TreeNodeSerde = serde_json::from_str(json_data)?;
209        Ok(Self::from_serde(serde_node))
210    }
211
212    fn to_serde(&self) -> TreeNodeSerde {
213        let inner = self.inner.borrow();
214        TreeNodeSerde {
215            guid: inner.guid,
216            name: inner.name.clone(),
217            children: inner
218                .children
219                .iter()
220                .map(|child| {
221                    TreeNode {
222                        inner: Rc::clone(child),
223                    }
224                    .to_serde()
225                })
226                .collect(),
227        }
228    }
229
230    fn from_serde(serde_node: TreeNodeSerde) -> Self {
231        let node = TreeNode::new(&serde_node.name);
232        node.inner.borrow_mut().guid = serde_node.guid;
233
234        for child_serde in serde_node.children {
235            let child = Self::from_serde(child_serde);
236            node.add(&child);
237        }
238
239        node
240    }
241
242    pub fn to_json(&self, filepath: &str) -> Result<(), Box<dyn std::error::Error>> {
243        let json = self.to_json_data()?;
244        fs::write(filepath, json)?;
245        Ok(())
246    }
247
248    pub fn from_json(filepath: &str) -> Result<Self, Box<dyn std::error::Error>> {
249        let json = fs::read_to_string(filepath)?;
250        Self::from_json_data(&json)
251    }
252}
253
254impl fmt::Display for TreeNode {
255    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
256        let inner = self.inner.borrow();
257        write!(
258            f,
259            "TreeNode({}, {}, {} children)",
260            inner.name,
261            inner.guid,
262            inner.children.len()
263        )
264    }
265}
266
267#[derive(Debug, Clone)]
268pub struct Tree {
269    pub guid: Uuid,
270    pub name: String,
271    root_node: Option<TreeNode>,
272}
273
274#[derive(Serialize, Deserialize)]
275#[serde(tag = "type", rename = "Tree")]
276struct TreeSerde {
277    guid: Uuid,
278    name: String,
279    root: Option<TreeNodeSerde>,
280}
281
282impl Tree {
283    pub fn new(name: &str) -> Self {
284        Self {
285            guid: Uuid::new_v4(),
286            name: name.to_string(),
287            root_node: None,
288        }
289    }
290
291    pub fn root(&self) -> Option<TreeNode> {
292        self.root_node.clone()
293    }
294
295    pub fn add(&mut self, node: &TreeNode, parent: Option<&TreeNode>) {
296        if parent.is_none() {
297            self.root_node = Some(node.clone());
298        } else if let Some(parent_node) = parent {
299            parent_node.add(node);
300        }
301    }
302
303    pub fn nodes(&self) -> Vec<TreeNode> {
304        if let Some(root) = &self.root_node {
305            root.nodes()
306        } else {
307            vec![]
308        }
309    }
310
311    pub fn remove(&mut self, node: &TreeNode) -> bool {
312        if let Some(root) = &self.root_node {
313            let node_guid = node.guid();
314            if root.guid() == node_guid {
315                self.root_node = None;
316                true
317            } else {
318                // Find parent and remove from there
319                if let Some(parent) = self.find_parent_of_node(&node_guid) {
320                    parent.remove(node)
321                } else {
322                    false
323                }
324            }
325        } else {
326            false
327        }
328    }
329
330    fn find_parent_of_node(&self, node_guid: &Uuid) -> Option<TreeNode> {
331        if let Some(root) = &self.root_node {
332            Self::find_parent_recursive(root, node_guid)
333        } else {
334            None
335        }
336    }
337
338    fn find_parent_recursive(node: &TreeNode, target_guid: &Uuid) -> Option<TreeNode> {
339        for child in node.children() {
340            if child.guid() == *target_guid {
341                return Some(node.clone());
342            }
343            if let Some(found) = Self::find_parent_recursive(&child, target_guid) {
344                return Some(found);
345            }
346        }
347        None
348    }
349
350    pub fn leaves(&self) -> Vec<TreeNode> {
351        self.nodes().into_iter().filter(|n| n.is_leaf()).collect()
352    }
353
354    pub fn traverse(&self, strategy: &str, order: &str) -> Vec<TreeNode> {
355        if let Some(root) = &self.root_node {
356            root.traverse(strategy, order)
357        } else {
358            vec![]
359        }
360    }
361
362    pub fn get_node_by_name(&self, node_name: &str) -> Option<TreeNode> {
363        self.nodes().into_iter().find(|n| n.name() == node_name)
364    }
365
366    pub fn get_nodes_by_name(&self, node_name: &str) -> Vec<TreeNode> {
367        self.nodes()
368            .into_iter()
369            .filter(|n| n.name() == node_name)
370            .collect()
371    }
372
373    pub fn find_node_by_guid(&self, node_guid: &Uuid) -> Option<TreeNode> {
374        self.nodes().into_iter().find(|n| n.guid() == *node_guid)
375    }
376
377    pub fn add_child_by_guid(&mut self, parent_guid: &Uuid, child_guid: &Uuid) -> bool {
378        let parent_node = self.find_node_by_guid(parent_guid);
379        let child_node = self.find_node_by_guid(child_guid);
380
381        if let (Some(parent), Some(child)) = (parent_node, child_node) {
382            // Remove child from its current parent if it has one
383            if let Some(current_parent) = child.parent() {
384                current_parent.remove(&child);
385            }
386
387            // Add to new parent
388            parent.add(&child);
389            true
390        } else {
391            false
392        }
393    }
394
395    pub fn get_children_guids(&self, node_guid: &Uuid) -> Vec<Uuid> {
396        if let Some(node) = self.find_node_by_guid(node_guid) {
397            node.children().iter().map(|c| c.guid()).collect()
398        } else {
399            vec![]
400        }
401    }
402
403    pub fn print_hierarchy(&self) {
404        if let Some(root) = &self.root_node {
405            Self::print_node(root, 0);
406        }
407    }
408
409    fn print_node(node: &TreeNode, level: usize) {
410        let indent = "  ".repeat(level);
411        println!("{}├── {} ({})", indent, node.name(), node.guid());
412
413        for child in node.children() {
414            Self::print_node(&child, level + 1);
415        }
416    }
417
418    pub fn to_json_data(&self) -> Result<String, Box<dyn std::error::Error>> {
419        let serde_tree = TreeSerde {
420            guid: self.guid,
421            name: self.name.clone(),
422            root: self.root_node.as_ref().map(|r| r.to_serde()),
423        };
424        let mut buf = Vec::new();
425        let formatter = serde_json::ser::PrettyFormatter::with_indent(b"    ");
426        let mut ser = serde_json::Serializer::with_formatter(&mut buf, formatter);
427        SerTrait::serialize(&serde_tree, &mut ser)?;
428        Ok(String::from_utf8(buf)?)
429    }
430
431    pub fn from_json_data(json_data: &str) -> Result<Self, Box<dyn std::error::Error>> {
432        let serde_tree: TreeSerde = serde_json::from_str(json_data)?;
433        let mut tree = Tree::new(&serde_tree.name);
434        tree.guid = serde_tree.guid;
435
436        if let Some(root_serde) = serde_tree.root {
437            let root = TreeNode::from_serde(root_serde);
438            tree.root_node = Some(root);
439        }
440
441        Ok(tree)
442    }
443
444    pub fn to_json(&self, filepath: &str) -> Result<(), Box<dyn std::error::Error>> {
445        let json = self.to_json_data()?;
446        fs::write(filepath, json)?;
447        Ok(())
448    }
449
450    pub fn from_json(filepath: &str) -> Result<Self, Box<dyn std::error::Error>> {
451        let json = fs::read_to_string(filepath)?;
452        Self::from_json_data(&json)
453    }
454}
455
456impl fmt::Display for Tree {
457    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
458        write!(f, "Tree({}, {})", self.name, self.guid)
459    }
460}
461
462impl Default for TreeNode {
463    fn default() -> Self {
464        Self::new("my_node")
465    }
466}
467
468impl Default for Tree {
469    fn default() -> Self {
470        Self::new("my_tree")
471    }
472}
session_rust/tree.rs

session_rust/
tree.rs
