core-dev 0.0.1

core-dev library is an utility library for rust. It contains a lot of useful functions and APIs to speed up development cycle.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

// use default_args::default_args;


type NodesOption = Option<Vec<TreeNode>>;

pub struct TreeNode {
    pub name:  String,
    pub path:  String,
    pub nodes: NodesOption,
}

impl PartialEq for TreeNode {
    fn eq(&self, other: &Self) -> bool {
        self.name == other.name
    }
}

impl TreeNode {
    pub fn new(
        name: String,
        path: String,
        nodes: NodesOption,
    ) -> Self {
        Self {
            name,
            path,
            nodes,
        }
    }

    pub fn find_node(&mut self, name: &str) -> Option<&mut TreeNode> {
        if let Some(nodes) = &mut self.nodes {
            for node in nodes.iter_mut() {
                if node.name == name {
                    return Some(node);
                }
            }
        }
        None
    }

    pub fn print_children(&self, level: u32) {
        let indent = "    ".repeat(level as usize);
        println!("{}Node:", indent);
        println!("{} value: {}", indent, self.name);
        println!("{} children:", indent);
        if let Some(children) = &self.nodes {
            for ch in children {
                println!("    {}", ch.name);
                match &ch.nodes {
                    Some(nodes) => {
                        for node in nodes {
                            node.print_children(level + 2);
                        }
                    },
                    None => {},
                }
            }
        }
    }

    pub fn add_node(&mut self, node: TreeNode) {
        if let Some(children) = &mut self.nodes {
            children.push(node);
        }
    }

    pub fn add_nodes(&mut self, nodes: Vec<TreeNode>) {
        if let Some(children) = &mut self.nodes {
            for (ch, node) in
                children.iter_mut().zip(nodes.into_iter())
            {
                match &mut ch.nodes {
                    Some(ch_nodes) => {
                        ch_nodes.push(node);
                    },
                    None => {},
                }
            }
        }
    }

    pub fn sort_nodes_alphabetically(head: &mut TreeNode) {
        if let Some(nodes) = &mut head.nodes {
            for node in nodes.iter_mut() {
                TreeNode::sort_nodes_alphabetically(node);
            }
            nodes.sort_by(|n1, n2| n1.name.cmp(&n2.name))
        }
    }

    fn _generate_summary(&self, level: usize) -> Vec<String> {
        let mut result = Vec::new();
        let indent = "    ".repeat(level);
        let line =
            format!("{}- [{}]({})", indent, self.name, self.path);
        // println!("{}", line);
        result.push(line);

        if let Some(nodes) = &self.nodes {
            for node in nodes {
                let indent = "    ".repeat(level + 1);
                let line = format!(
                    "{}- [{}]({})",
                    indent, node.name, node.path
                );
                // println!("{}", line);
                result.push(line);

                match &node.nodes {
                    Some(nodes) => {
                        for node in nodes {
                            result.extend(
                                node._generate_summary(level + 2),
                            );
                        }
                    },
                    None => {},
                }
            }
        }
        result
    }

    pub fn generate_summary(&self, level: usize) -> Vec<String> {
        let mut summary_vec =
            vec!["# Summary".to_string(), "".to_string()];
        if let Some(nodes) = &self.nodes {
            for node in nodes {
                summary_vec.extend(node._generate_summary(level));
            }
        }
        summary_vec
    }

    pub fn generate_summary_string(&self) -> String {
        let mut summary_string = String::new();
        let summary = self.generate_summary(0);
        for line in summary.iter() {
            let ll = line.clone() + "\n";
            summary_string.push_str(&ll);
        }
        summary_string
    }
}