layout 0.1.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

//! Ergonomic surface of `Compact<T>`: deref to the inner value, direct
//! comparisons against `T`, and `Into`-accepting `CompactVec` mutators.

use layout::{Compact, CompactVec};

#[test]
fn deref_and_compare() {
    let c = Compact::new(true);
    assert!(*c);
    assert_eq!(c, true);
    assert!(c > false);

    let mut m = Compact::new(false);
    *m = true;
    assert!(m.get());
}

#[test]
fn mutators_accept_plain_values() {
    let mut v: CompactVec<bool> = CompactVec::new();
    v.push(true);
    v.push(Compact::new(false));
    v.insert(1, true);
    assert_eq!(v.len(), 3);
    assert!(v.get(1).unwrap().get());

    v.set(0, false);
    assert!(!v.get(0).unwrap().get());

    let old = v.replace(2, true);
    assert!(!old.get());
    assert!(v.get(2).unwrap().get());

    v.resize(70, true);
    assert_eq!(v.len(), 70);
    assert!(v.get(69).unwrap().get());
    v.resize(2, false);
    assert_eq!(v.len(), 2);
}

#[repr(u8)]
#[derive(
    Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, layout::CompactRepr,
)]
enum Kind {
    A,
    B,
}

#[test]
fn enum_columns_take_plain_variants() {
    let mut v: CompactVec<Kind> = CompactVec::new();
    v.push(Kind::A);
    v.push(Kind::B);
    assert_eq!(v.get(0).unwrap(), Kind::A);
    assert_eq!(*v.get(1).unwrap(), Kind::B);
}