layout 0.2.0

Optimized memory layout using struct of array, Data-oriented design in Rust, DOD SOA
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

//! Range-bound handling for the compact column's range-taking methods.
//!
//! An inclusive end of `usize::MAX` has no exclusive equivalent. It must be
//! rejected like `Vec`'s, not wrapped to an empty range that silently does
//! nothing (which is what plain `+ 1` does once overflow checks are off).
extern crate alloc;

use core::ops::Bound;

use layout::{Compact, CompactVec};

fn bv(len: usize) -> CompactVec<bool> {
    (0..len).map(|i| Compact(i % 2 == 0)).collect()
}

#[test]
#[should_panic]
fn drain_inclusive_max_end_panics() {
    let mut v = bv(8);
    let _ = v.drain(..=usize::MAX);
}

#[test]
#[should_panic]
fn splice_inclusive_max_end_panics() {
    let mut v = bv(8);
    let _ = v.splice(..=usize::MAX, [Compact(true)]);
}

#[test]
#[should_panic]
fn drain_excluded_max_start_panics() {
    let mut v = bv(8);
    let _ = v.drain((Bound::Excluded(usize::MAX), Bound::Unbounded));
}

#[test]
fn drain_inclusive_end_within_bounds() {
    let mut v = bv(8);
    let drained: alloc::vec::Vec<_> = v.drain(2..=4).collect();
    assert_eq!(drained.len(), 3);
    assert_eq!(v.len(), 5);
}

#[test]
fn drain_inclusive_last_index() {
    let mut v = bv(8);
    let drained: alloc::vec::Vec<_> = v.drain(5..=7).collect();
    assert_eq!(drained.len(), 3);
    assert_eq!(v.len(), 5);
}

#[test]
fn splice_inclusive_end_within_bounds() {
    let mut v = bv(8);
    let removed = v.splice(1..=2, [Compact(false)]);
    assert_eq!(removed.len(), 2);
    assert_eq!(v.len(), 7);
}