core_dev/collections/
tree.rs

1// use default_args::default_args;
2
3
4type NodesOption = Option<Vec<TreeNode>>;
5
6pub struct TreeNode {
7    pub name:  String,
8    pub path:  String,
9    pub nodes: NodesOption,
10}
11
12impl PartialEq for TreeNode {
13    fn eq(&self, other: &Self) -> bool {
14        self.name == other.name
15    }
16}
17
18impl TreeNode {
19    pub fn new(
20        name: String,
21        path: String,
22        nodes: NodesOption,
23    ) -> Self {
24        Self {
25            name,
26            path,
27            nodes,
28        }
29    }
30
31    pub fn find_node(&mut self, name: &str) -> Option<&mut TreeNode> {
32        if let Some(nodes) = &mut self.nodes {
33            for node in nodes.iter_mut() {
34                if node.name == name {
35                    return Some(node);
36                }
37            }
38        }
39        None
40    }
41
42    pub fn print_children(&self, level: u32) {
43        let indent = "    ".repeat(level as usize);
44        println!("{}Node:", indent);
45        println!("{} value: {}", indent, self.name);
46        println!("{} children:", indent);
47        if let Some(children) = &self.nodes {
48            for ch in children {
49                println!("    {}", ch.name);
50                match &ch.nodes {
51                    Some(nodes) => {
52                        for node in nodes {
53                            node.print_children(level + 2);
54                        }
55                    },
56                    None => {},
57                }
58            }
59        }
60    }
61
62    pub fn add_node(&mut self, node: TreeNode) {
63        if let Some(children) = &mut self.nodes {
64            children.push(node);
65        }
66    }
67
68    pub fn add_nodes(&mut self, nodes: Vec<TreeNode>) {
69        if let Some(children) = &mut self.nodes {
70            for (ch, node) in
71                children.iter_mut().zip(nodes.into_iter())
72            {
73                match &mut ch.nodes {
74                    Some(ch_nodes) => {
75                        ch_nodes.push(node);
76                    },
77                    None => {},
78                }
79            }
80        }
81    }
82
83    pub fn sort_nodes_alphabetically(head: &mut TreeNode) {
84        if let Some(nodes) = &mut head.nodes {
85            for node in nodes.iter_mut() {
86                TreeNode::sort_nodes_alphabetically(node);
87            }
88            nodes.sort_by(|n1, n2| n1.name.cmp(&n2.name))
89        }
90    }
91
92    fn _generate_summary(&self, level: usize) -> Vec<String> {
93        let mut result = Vec::new();
94        let indent = "    ".repeat(level);
95        let line =
96            format!("{}- [{}]({})", indent, self.name, self.path);
97        // println!("{}", line);
98        result.push(line);
99
100        if let Some(nodes) = &self.nodes {
101            for node in nodes {
102                let indent = "    ".repeat(level + 1);
103                let line = format!(
104                    "{}- [{}]({})",
105                    indent, node.name, node.path
106                );
107                // println!("{}", line);
108                result.push(line);
109
110                match &node.nodes {
111                    Some(nodes) => {
112                        for node in nodes {
113                            result.extend(
114                                node._generate_summary(level + 2),
115                            );
116                        }
117                    },
118                    None => {},
119                }
120            }
121        }
122        result
123    }
124
125    pub fn generate_summary(&self, level: usize) -> Vec<String> {
126        let mut summary_vec =
127            vec!["# Summary".to_string(), "".to_string()];
128        if let Some(nodes) = &self.nodes {
129            for node in nodes {
130                summary_vec.extend(node._generate_summary(level));
131            }
132        }
133        summary_vec
134    }
135
136    pub fn generate_summary_string(&self) -> String {
137        let mut summary_string = String::new();
138        let summary = self.generate_summary(0);
139        for line in summary.iter() {
140            let ll = line.clone() + "\n";
141            summary_string.push_str(&ll);
142        }
143        summary_string
144    }
145}
core_dev/collections/tree.rs

core_dev/collections/
tree.rs
