multi_key_map 0.3.0

a hash table that shares one value across multiple keys.
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

use crate::MultiKeyMap;

#[test]
fn get_mut_test() {
    let mut map = MultiKeyMap::new();
    map.insert(1, "foo".to_string());
    let x = map.get_mut(&1).unwrap();
    *x = "bar".to_string();
    assert_eq!(Some(&"bar".to_string()), map.get(&1));
}

#[test]
fn insert_test() {
    let mut map = MultiKeyMap::new();
    map.insert(1, 2);
    assert_eq!(Some(&2), map.get(&1));
}

#[test]
fn insert_many_test() {
    let mut map = MultiKeyMap::new();
    map.insert_many(vec![1, 2], "foo".to_string());
    assert_eq!(Some(&"foo".to_string()), map.get(&1));
    assert_eq!(Some(&"foo".to_string()), map.get(&2));
}

#[test]
fn alias_test() {
    let mut map = MultiKeyMap::new();
    map.insert(1, 2);
    let result = map.alias(&1, 3);
    assert_eq!(result, Ok(&mut 2));
    assert_eq!(Some(&2), map.get(&3));
    let result = map.alias(&2, 4);
    assert_eq!(result, Err(4));
    assert_eq!(None, map.get(&4));
}

#[test]
fn alias_many_test() {
    let mut map = MultiKeyMap::new();
    map.insert(1, 2);
    let result = map.alias_many(&1, vec![3, 4, 5]);
    assert_eq!(result, Ok(&mut 2));
    assert_eq!(Some(&2), map.get(&3));
    assert_eq!(Some(&2), map.get(&4));
    assert_eq!(Some(&2), map.get(&5));
    let result = map.alias_many(&2, vec![6, 7, 8]);
    assert_eq!(result, Err(vec![6, 7, 8]));
    assert_eq!(None, map.get(&6));
    assert_eq!(None, map.get(&7));
    assert_eq!(None, map.get(&8));
}

#[test]
fn remove_test() {
    let mut map = MultiKeyMap::new();
    map.insert_many(vec![1, 2], 3);
    assert_eq!(None, map.remove(&1));
    assert_eq!(Some(3), map.remove(&2));
}

#[test]
fn remove_many_test() {
    let mut map = MultiKeyMap::new();
    map.insert(1, 2);
    map.insert(3, 4);
    assert_eq!(vec![2, 4], map.remove_many([&1, &3]));
}

#[test]
fn from_test() {
    let map = MultiKeyMap::from([(vec![1, 2], 3), (vec![4, 5], 6), (vec![7, 8, 9], 10)]);
    assert_eq!(Some(&3), map.get(&1));
    assert_eq!(Some(&3), map.get(&2));
    assert_eq!(Some(&6), map.get(&4));
    assert_eq!(Some(&6), map.get(&5));
    assert_eq!(Some(&10), map.get(&7));
    assert_eq!(Some(&10), map.get(&8));
    assert_eq!(Some(&10), map.get(&9));
}

#[test]
fn entry_insert_test() {
    let mut map = MultiKeyMap::from([(vec![1, 2], 3), (vec![4, 5], 6)]);
    map.entry(7).or_insert(-1);
    assert_eq!(Some(&-1), map.get(&7));
}

#[test]
fn entry_insert_with_test() {
    let mut map = MultiKeyMap::from([(vec![1, 2], 3), (vec![4, 5], 6)]);
    map.entry(7).or_insert_with(|| -1);
    assert_eq!(Some(&-1), map.get(&7));
}

#[test]
fn entry_insert_with_key_test() {
    let mut map = MultiKeyMap::from([(vec![1, 2], 3), (vec![4, 5], 6)]);
    map.entry(7).or_insert_with_key(|k| *k + 1);
    assert_eq!(Some(&8), map.get(&7));
}

#[test]
fn entry_modify_test() {
    let mut map = MultiKeyMap::from([(vec![1, 2], 3), (vec![4, 5], 6)]);
    map.entry(1).and_modify(|x| *x = *x + 1).or_insert(-1);
    assert_eq!(Some(&4), map.get(&1));
}

#[test]
fn entry_default_test() {
    let mut map = MultiKeyMap::from([
        (vec![1, 2], String::from("foo")),
        (vec![4, 5], String::from("bar")),
    ]);
    map.entry(7).or_default();
    assert_eq!(Some(&String::new()), map.get(&7));
}