orx-split-vec 3.22.0

An efficient dynamic capacity vector with pinned element guarantees.
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

use crate::{
    Growth, SplitVec,
    common_traits::iterator::{SliceBorrowAsMut, iter_of_slices::IterOfSlices},
    range_helpers::{range_end, range_start},
};
use alloc::vec::Vec;
use core::cmp::min;
use core::ops::Range;
use orx_pinned_vec::*;
use test_case::test_matrix;

#[cfg(not(miri))]
const N: [usize; 8] = [0, 1, 3, 4, 5, 8, 185, 423];
#[cfg(miri)]
const N: [usize; 8] = [0, 1, 3, 4, 5, 8, 27, 37];

fn init_vec<G: Growth>(mut vec: SplitVec<usize, G>, n: usize) -> SplitVec<usize, G> {
    vec.clear();
    vec.extend(0..n);
    vec
}

#[test_matrix(
    [SplitVec::with_doubling_growth(), SplitVec::with_linear_growth(2), SplitVec::with_recursive_growth()],
    [0..0, 0..1, 4..4, 4..5, 1..4, 2..6, 2..15, 4..11, 4..12, 4..13, 4..59, 5..9, 5..12, 7..28, 7..60, 4..28, 4..60, 0..28, 0..60]
)]
fn slices_iter_mut(vec: SplitVec<usize, impl Growth>, range: Range<usize>) {
    for n in N {
        let mut vec = init_vec(vec.clone(), n);

        let a = min(range_start(&range), n);
        let b = min(range_end(&range, n), n);
        let expected: Vec<_> = (a..b).collect();

        let slices = IterOfSlices::<_, SliceBorrowAsMut>::new(&mut vec, a..b);
        for x in slices {
            for x in x {
                *x += 25;
            }
        }
        let slices = IterOfSlices::<_, SliceBorrowAsMut>::new(&mut vec, a..b);
        for x in slices {
            for x in x {
                *x -= 25;
            }
        }

        let slices = IterOfSlices::<_, SliceBorrowAsMut>::new(&mut vec, a..b);
        let values: Vec<_> = slices.flat_map(|x| x.iter()).copied().collect();

        assert_eq!(values, expected);
    }
}

#[test]
fn slices_iter_mut_empty() {
    let mut iter = IterOfSlices::<u32, SliceBorrowAsMut>::default();
    assert_eq!(iter.next(), None);
    assert_eq!(iter.next(), None);
    assert_eq!(iter.next(), None);
}

#[test]
fn slices_iter_mut_fused() {
    let mut vec = init_vec(SplitVec::new(), 100);
    let mut slices = IterOfSlices::<_, SliceBorrowAsMut>::new(&mut vec, 3..87);
    let mut expected = 3;

    while let Some(slice) = slices.next() {
        for x in slice {
            assert_eq!(*x, expected);
            expected += 1;
        }
    }

    assert!(slices.next().is_none());
    assert!(slices.next().is_none());
}

#[test]
fn slices_iter_mut_exact_sized() {
    let mut vec = init_vec(SplitVec::new(), 20);

    let mut empty = IterOfSlices::<_, SliceBorrowAsMut>::new(&mut vec, 20..87);
    assert_eq!(empty.len(), 0);
    _ = empty.next();
    _ = empty.next();
    assert_eq!(empty.len(), 0);

    let mut single = IterOfSlices::<_, SliceBorrowAsMut>::new(&mut vec, 5..11);
    assert_eq!(single.len(), 1);
    _ = single.next();
    assert_eq!(single.len(), 0);
    _ = single.next();
    assert_eq!(single.len(), 0);

    let mut two = IterOfSlices::<_, SliceBorrowAsMut>::new(&mut vec, 5..13);
    assert_eq!(two.len(), 2);
    _ = two.next();
    assert_eq!(two.len(), 1);
    _ = two.next();
    assert_eq!(two.len(), 0);
    _ = two.next();
    assert_eq!(two.len(), 0);

    let mut three = IterOfSlices::<_, SliceBorrowAsMut>::new(&mut vec, 3..13);
    assert_eq!(three.len(), 3);
    _ = three.next();
    assert_eq!(three.len(), 2);
    _ = three.next();
    assert_eq!(three.len(), 1);
    _ = three.next();
    assert_eq!(three.len(), 0);
    _ = three.next();
    assert_eq!(three.len(), 0);
}