prefix-trie 0.8.3

Prefix trie (tree) datastructure (both a set and a map) that provides exact and longest-prefix matches.
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

use crate::*;
use ipnet::Ipv4Net;

#[test]
fn map_view_transformations() {
    let mut map: PrefixMap<Ipv4Net, usize> = PrefixMap::new();
    map.insert("10.0.0.1/8".parse().unwrap(), 1);
    map.insert("10.1.0.2/16".parse().unwrap(), 2);
    map.insert("10.2.0.3/16".parse().unwrap(), 3);

    let elems = map.keys().copied().collect::<Vec<_>>();

    assert_eq!(elems, map.view().keys().copied().collect::<Vec<_>>());
    assert_eq!(elems, map.view().view().keys().copied().collect::<Vec<_>>());
    assert_eq!(
        elems,
        map.view_mut().view().keys().copied().collect::<Vec<_>>()
    );

    let map_ref = &map;
    assert_eq!(elems, map_ref.view().keys().copied().collect::<Vec<_>>());
}

#[test]
fn set_view_transformations() {
    let mut set: PrefixSet<Ipv4Net> = PrefixSet::new();
    set.insert("10.0.0.1/8".parse().unwrap());
    set.insert("10.1.0.2/16".parse().unwrap());
    set.insert("10.2.0.3/16".parse().unwrap());

    let elems = set.iter().copied().collect::<Vec<_>>();

    assert_eq!(elems, set.view().keys().copied().collect::<Vec<_>>());
    assert_eq!(elems, set.view().view().keys().copied().collect::<Vec<_>>());
    assert_eq!(
        elems,
        set.view_mut().view().keys().copied().collect::<Vec<_>>()
    );

    let set_ref = &set;
    assert_eq!(elems, set_ref.view().keys().copied().collect::<Vec<_>>());
}

#[test]
fn debug() {
    let mut map: PrefixMap<Ipv4Net, usize> = PrefixMap::new();
    map.insert("10.0.0.1/8".parse().unwrap(), 1);
    map.insert("10.1.0.2/16".parse().unwrap(), 2);
    map.insert("10.2.0.3/16".parse().unwrap(), 3);

    assert_eq!(format!("{:?}", map.view()), "View(0.0.0.0/0)");
    assert_eq!(
        format!("{:?}", map.view_at("10.0.0.0/8".parse().unwrap()).unwrap()),
        "View(10.0.0.1/8)"
    );

    assert_eq!(format!("{:?}", map.view_mut()), "ViewMut(0.0.0.0/0)");
    assert_eq!(
        format!(
            "{:?}",
            map.view_mut_at("10.0.0.0/8".parse().unwrap()).unwrap()
        ),
        "ViewMut(10.0.0.1/8)"
    );
}

#[test]
fn eq() {
    let mut map1: PrefixMap<Ipv4Net, usize> = PrefixMap::new();
    map1.insert("10.0.0.1/8".parse().unwrap(), 1);
    map1.insert("10.1.0.2/16".parse().unwrap(), 2);
    map1.insert("10.2.0.3/16".parse().unwrap(), 3);

    let mut map2: PrefixMap<Ipv4Net, usize> = PrefixMap::new();
    map2.insert("10.0.0.1/8".parse().unwrap(), 1);
    map2.insert("10.1.0.2/16".parse().unwrap(), 2);
    map2.insert("10.2.0.3/16".parse().unwrap(), 3);

    let mut map3: PrefixMap<Ipv4Net, usize> = PrefixMap::new();
    map3.insert("10.0.0.1/8".parse().unwrap(), 1);
    map3.insert("10.1.0.2/16".parse().unwrap(), 2);
    map3.insert("10.2.0.9/16".parse().unwrap(), 3);

    assert_eq!(map1.view(), map2.view());
    assert_eq!(
        map1.view(),
        map2.view_at("10.0.0.0/8".parse().unwrap()).unwrap()
    );
    assert_ne!(map1.view(), map3.view());

    assert_eq!(map1.view_mut(), map2.view());
    assert_eq!(map1.view_mut(), map2.view_mut());
    assert_eq!(
        map1.view_mut(),
        map2.view_at("10.0.0.0/8".parse().unwrap()).unwrap()
    );
    assert_ne!(map1.view_mut(), map3.view_mut());
}