1use crate::treenode::{TreeNode, TreeNodeSerde};
2use serde::{ser::Serialize as SerTrait, Deserialize, Serialize};
3use std::fmt;
4use uuid::Uuid;
5
6#[derive(Debug, Clone)]
7pub struct Tree {
8 pub guid: String,
9 pub name: String,
10 root_node: Option<TreeNode>,
11}
12
13impl Serialize for Tree {
14 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
15 where
16 S: serde::Serializer,
17 {
18 let serde_tree = TreeSerde {
19 guid: self.guid.clone(),
20 name: self.name.clone(),
21 root: self.root_node.as_ref().map(|r| r.to_serde()),
22 };
23 serde_tree.serialize(serializer)
24 }
25}
26
27impl<'de> Deserialize<'de> for Tree {
28 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
29 where
30 D: serde::Deserializer<'de>,
31 {
32 let serde_tree = TreeSerde::deserialize(deserializer)?;
33 let mut tree = Tree {
34 guid: serde_tree.guid,
35 name: serde_tree.name,
36 root_node: None,
37 };
38 if let Some(root_serde) = serde_tree.root {
39 tree.root_node = Some(TreeNode::from_serde(root_serde));
40 }
41 Ok(tree)
42 }
43}
44
45#[derive(Serialize, Deserialize)]
46#[serde(tag = "type", rename = "Tree")]
47struct TreeSerde {
48 guid: String,
49 name: String,
50 root: Option<TreeNodeSerde>,
51}
52
53impl Tree {
54 pub fn new(name: &str) -> Self {
55 Self {
56 guid: Uuid::new_v4().to_string(),
57 name: name.to_string(),
58 root_node: None,
59 }
60 }
61
62 pub fn root(&self) -> Option<TreeNode> {
63 self.root_node.clone()
64 }
65
66 pub fn add(&mut self, node: &TreeNode, parent: Option<&TreeNode>) {
67 if parent.is_none() {
68 self.root_node = Some(node.clone());
69 } else if let Some(parent_node) = parent {
70 parent_node.add(node);
71 }
72 }
73
74 pub fn nodes(&self) -> Vec<TreeNode> {
75 if let Some(root) = &self.root_node {
76 root.nodes()
77 } else {
78 vec![]
79 }
80 }
81
82 pub fn remove(&mut self, node: &TreeNode) -> bool {
83 if let Some(root) = &self.root_node {
84 let node_guid = node.guid();
85 if root.guid() == node_guid {
86 self.root_node = None;
87 true
88 } else if let Some(parent) = self.find_parent_of_node(&node_guid) {
89 parent.remove(node)
90 } else {
91 false
92 }
93 } else {
94 false
95 }
96 }
97
98 fn find_parent_of_node(&self, node_guid: &String) -> Option<TreeNode> {
99 if let Some(root) = &self.root_node {
100 Self::find_parent_recursive(root, node_guid)
101 } else {
102 None
103 }
104 }
105
106 fn find_parent_recursive(node: &TreeNode, target_guid: &String) -> Option<TreeNode> {
107 for child in node.children() {
108 if child.guid() == *target_guid {
109 return Some(node.clone());
110 }
111 if let Some(found) = Self::find_parent_recursive(&child, target_guid) {
112 return Some(found);
113 }
114 }
115 None
116 }
117
118 pub fn leaves(&self) -> Vec<TreeNode> {
119 self.nodes().into_iter().filter(|n| n.is_leaf()).collect()
120 }
121
122 pub fn traverse(&self, strategy: &str, order: &str) -> Vec<TreeNode> {
123 if let Some(root) = &self.root_node {
124 root.traverse(strategy, order)
125 } else {
126 vec![]
127 }
128 }
129
130 pub fn get_node_by_name(&self, node_name: &str) -> Option<TreeNode> {
131 self.nodes().into_iter().find(|n| n.name() == node_name)
132 }
133
134 pub fn get_nodes_by_name(&self, node_name: &str) -> Vec<TreeNode> {
135 self.nodes()
136 .into_iter()
137 .filter(|n| n.name() == node_name)
138 .collect()
139 }
140
141 pub fn find_node_by_guid(&self, node_guid: &String) -> Option<TreeNode> {
142 self.nodes().into_iter().find(|n| n.guid() == *node_guid)
143 }
144
145 pub fn add_child_by_guid(&mut self, parent_guid: &String, child_guid: &String) -> bool {
146 let parent_node = self.find_node_by_guid(parent_guid);
147 let child_node = self.find_node_by_guid(child_guid);
148
149 if let (Some(parent), Some(child)) = (parent_node, child_node) {
150 if let Some(current_parent) = child.parent() {
151 current_parent.remove(&child);
152 }
153 parent.add(&child);
154 true
155 } else {
156 false
157 }
158 }
159
160 pub fn get_children_guids(&self, node_guid: &String) -> Vec<String> {
161 if let Some(node) = self.find_node_by_guid(node_guid) {
162 node.children().iter().map(|c| c.guid()).collect()
163 } else {
164 vec![]
165 }
166 }
167
168 pub fn get_children(&self, node_guid: &str) -> Vec<String> {
169 self.get_children_guids(&node_guid.to_string())
170 }
171
172 pub fn print_hierarchy(&self) {
173 if let Some(root) = &self.root_node {
174 Self::print_node(root, 0);
175 }
176 }
177
178 fn print_node(node: &TreeNode, level: usize) {
179 let indent = " ".repeat(level);
180 println!("{}├── {} ({})", indent, node.name(), node.guid());
181
182 for child in node.children() {
183 Self::print_node(&child, level + 1);
184 }
185 }
186
187 pub fn jsondump(&self) -> Result<String, Box<dyn std::error::Error>> {
188 let serde_tree = TreeSerde {
189 guid: self.guid.clone(),
190 name: self.name.clone(),
191 root: self.root_node.as_ref().map(|r| r.to_serde()),
192 };
193 let mut buf = Vec::new();
194 let formatter = serde_json::ser::PrettyFormatter::with_indent(b" ");
195 let mut ser = serde_json::Serializer::with_formatter(&mut buf, formatter);
196 SerTrait::serialize(&serde_tree, &mut ser)?;
197 Ok(String::from_utf8(buf)?)
198 }
199
200 pub fn jsonload(json_data: &str) -> Result<Self, Box<dyn std::error::Error>> {
201 let serde_tree: TreeSerde = serde_json::from_str(json_data)?;
202 let mut tree = Tree::new(&serde_tree.name);
203 tree.guid = serde_tree.guid;
204
205 if let Some(root_serde) = serde_tree.root {
206 let root = TreeNode::from_serde(root_serde);
207 tree.root_node = Some(root);
208 }
209
210 Ok(tree)
211 }
212}
213
214impl fmt::Display for Tree {
215 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
216 write!(f, "Tree({}, {})", self.name, self.guid)
217 }
218}
219
220impl Default for Tree {
221 fn default() -> Self {
222 Self::new("my_tree")
223 }
224}
225
226#[cfg(test)]
227#[path = "tree_test.rs"]
228mod tree_test;