gen_map 0.3.0

A generational map with configurable key size, key layout and storage.
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

use crate::{GenMap, GenMapConfig, GenSlotItem, InsertError, MapConfig, Split};
use std::string::{String, ToString};
use std::vec::Vec;

struct Byte;

impl MapConfig for Byte {
    type KeyConfig = Split<u8, u8>;
}

impl<S: GenSlotItem> GenMapConfig<S> for Byte {
    type Storage = Vec<S>;
}

#[test]
fn try_insert_works_like_insert_while_there_is_room() {
    let mut map = GenMap::new();
    let a = map.try_insert(1).unwrap();
    let b = map.try_insert(2).unwrap();
    assert_eq!(map[a], 1);
    assert_eq!(map[b], 2);
    assert_eq!(map.len(), 2);
}

#[test]
fn try_insert_hands_the_value_back_when_the_index_runs_out() {
    let mut map = GenMap::<String, Byte>::new_with_config();
    // No slot gets the index `u8::MAX`, so the map holds 255 values.
    for i in 0..255 {
        map.try_insert(i.to_string()).unwrap();
    }
    match map.try_insert("late".to_string()) {
        Err(InsertError::IndexExhausted(value)) => assert_eq!(value, "late"),
        other => panic!("expected IndexExhausted, got {other:?}"),
    }
    assert_eq!(map.len(), 255);
    assert_eq!(map.slots_len(), 255);
}

#[test]
fn into_inner_takes_the_value_back() {
    assert_eq!(InsertError::<_, ()>::IndexExhausted(5).into_inner(), 5);
    assert_eq!(InsertError::StorageFull("x", ()).into_inner(), "x");
}

#[test]
fn the_error_does_not_need_debug_from_the_value() {
    struct Opaque;
    let text = std::format!("{:?}", InsertError::<_, ()>::IndexExhausted(Opaque));
    assert_eq!(text, "IndexExhausted(..)");
    let text = std::format!("{:?}", InsertError::StorageFull(Opaque, "why"));
    assert_eq!(text, "StorageFull(.., \"why\")");
    let text = std::format!("{}", InsertError::StorageFull(Opaque, "why"));
    assert!(text.contains("storage") && text.contains("why"));
}

#[test]
#[should_panic(expected = "cannot address more than 255 slots")]
fn insert_panics_when_the_index_runs_out() {
    let mut map = GenMap::<i32, Byte>::new_with_config();
    for i in 0..256 {
        map.insert(i);
    }
}