willowtree 0.2.0

Lazily evaluated trees
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

use std::fs;

use willowtree::Tree;

#[derive(Debug, Hash, Eq, PartialEq)]
struct Node {
    path: String,
}

impl Node {
    fn new(path: String) -> Self {
        Self { path }
    }
}

impl willowtree::Node for Node {
    fn children(&self) -> Vec<Self> {
        // check if path is file using fs
        // if so, return empty vec

        let children = fs::read_dir(&self.path);

        match children {
            Ok(children) => children
                .map(|file| {
                    let path = file.unwrap().path().to_str().unwrap().to_string();

                    Node::new(path)
                })
                .collect(),
            Err(_) => vec![],
        }
    }

    fn leaf(&self) -> bool {
        let md = fs::metadata(&self.path);

        match md {
            Ok(metadata) => metadata.is_file(),
            Err(_) => true,
        }
    }
}

fn walk(tree: &mut Tree<Node>, id: willowtree::Id, depth: usize) {
    if depth == 5 {
        return;
    }

    for child in &mut tree.children(id) {
        walk(tree, *child, depth + 1);
    }
}

fn main() {
    let mut tree = Tree::<Node>::new(Node::new("/".to_string()));

    let root = tree.root();

    walk(&mut tree, root, 0);
}