ego-tree 0.11.0

Vec-backed ID-tree
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

use std::assert_eq;

use ego_tree::tree;

#[test]
fn sort() {
    let mut tree = tree!('a' => { 'd' => { 'e', 'f' }, 'c',  'b' });
    tree.root_mut().sort();
    assert_eq!(
        vec![&'b', &'c', &'d'],
        tree.root()
            .children()
            .map(|n| n.value())
            .collect::<Vec<_>>(),
    );
    assert_eq!(
        tree.to_string(),
        tree!('a' => { 'b', 'c',  'd' => { 'e', 'f' } }).to_string()
    );
}

#[test]
fn sort_by() {
    let mut tree = tree!('a' => { 'c', 'd', 'b' });
    tree.root_mut().sort_by(|a, b| b.value().cmp(a.value()));
    assert_eq!(
        vec![&'d', &'c', &'b'],
        tree.root()
            .children()
            .map(|n| n.value())
            .collect::<Vec<_>>(),
    );

    let mut tree = tree!('a' => { 'c','d', 'e', 'b' });
    tree.root_mut().sort_by(|a, b| b.value().cmp(a.value()));
    assert_eq!(
        vec![&'e', &'d', &'c', &'b'],
        tree.root()
            .children()
            .map(|n| n.value())
            .collect::<Vec<_>>(),
    );
}

#[test]
fn sort_by_key() {
    let mut tree = tree!("1a" => { "2b", "4c", "3d" });
    tree.root_mut()
        .sort_by_key(|a| a.value().split_at(1).0.parse::<i32>().unwrap());
    assert_eq!(
        vec!["2b", "3d", "4c"],
        tree.root()
            .children()
            .map(|n| *n.value())
            .collect::<Vec<_>>(),
    );
}

#[test]
fn sort_id() {
    let mut tree = tree!('a' => { 'd', 'c', 'b' });
    tree.root_mut().sort();
    assert_ne!(
        vec![&'d', &'c', &'b'],
        tree.root()
            .children()
            .map(|n| n.value())
            .collect::<Vec<_>>(),
    );
    tree.root_mut().sort_by_key(|n| n.id());
    assert_eq!(
        vec![&'d', &'c', &'b'],
        tree.root()
            .children()
            .map(|n| n.value())
            .collect::<Vec<_>>(),
    );
}

#[test]
fn sort_by_id() {
    let mut tree = tree!('a' => { 'd', 'b', 'c' });
    tree.root_mut().sort_by(|a, b| b.id().cmp(&a.id()));
    assert_eq!(
        vec![&'c', &'b', &'d'],
        tree.root()
            .children()
            .map(|n| n.value())
            .collect::<Vec<_>>(),
    );
}