slice_map 0.2.7

A generic container to store a single type of data into unevenly sized slices.
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

use crate::SlotSliceMap;
use slotmap::new_key_type;

extern crate alloc;
use alloc::vec::Vec;

new_key_type! {
    pub struct TestKey;
}

// #[test]
// fn doc_test(){
// }

#[test]
fn test_basic() {
    let mut slicemap = SlotSliceMap::<TestKey, i32>::new();
    let max_slices = 10;
    let mut item_count = 1;
    let mut item_len = 0;
    for slice in 1..=max_slices {
        let values: Vec<i32> = (1..=item_count as i32).into_iter().collect();
        item_len += values.len();
        item_count += 1;
        slicemap.add_items(values);
        assert_eq!(slicemap.items_len(), item_len);
        assert_eq!(slicemap.slices_len(), slice);
        // println!("{:?}", s);
    }
}

#[test]
fn test_remove() {
    let mut slicemap = SlotSliceMap::<TestKey, i32>::new();

    let a = slicemap.add_items([1, 2, 3, 4, 5]);
    let b = slicemap.add_items([6, 7]);
    let c = slicemap.add_items([8, 9, 10]);
    assert_eq!(slicemap.items_len(), 10);
    assert_eq!(slicemap.slices_len(), 3);

    // Remove
    slicemap.remove_slice(b);

    // Iterating over slices
    assert_eq!(slicemap.slices_len(), 2);
    let mut slices = slicemap.iter_slices();
    assert_eq!(slices.next().unwrap(), [1, 2, 3, 4, 5]);
    assert_eq!(slices.next().unwrap(), [8, 9, 10]);
    assert_eq!(slices.next(), None);
    drop(slices);

    // Iterating over all items
    let mut value = 1;
    for (i, item) in slicemap.iter_items().enumerate() {
        if i < 5 {
            assert_eq!(value, *item);
        } else {
            assert_eq!(value + 2, *item);
        }
        value += 1
    }

    // Remove and test again
    slicemap.remove_slice(a);
    assert_eq!(slicemap.slices_len(), 1);
    let mut slices = slicemap.iter_slices();
    assert_eq!(slices.next().unwrap(), [8, 9, 10]);
    assert_eq!(slices.next(), None);
    let mut value = 8;
    for item in slicemap.iter_items() {
        assert_eq!(value, *item);
        value += 1
    }
    drop(slices);

    // Empty
    slicemap.remove_slice(c);
    assert_eq!(slicemap.items_len(), 0);
    assert_eq!(slicemap.slices_len(), 0);
}

#[test]
fn non_default_values() {
    #[derive(Clone)]
    struct Test; // No default implementation
    let mut slices = SlotSliceMap::<TestKey, Test>::new();
    let ref_array = &[Test, Test, Test];
    slices.add_items(ref_array);
    slices.add_items([Test]);
    assert_eq!(slices.items_len(), 4);
    assert_eq!(slices.slices_len(), 2);
}