hvec 0.5.1

A Vec-like structure that can store different types of different sizes contiguous with each other in memory.
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

#[test]
#[cfg(not(feature = "no_drop"))]
pub fn push_and_drop_runs_destructors() {
    use hvec::HVec;

    static mut A_COUNT: u8 = 0;
    static mut B_COUNT: u8 = 0;
    static mut C_COUNT: u8 = 0;

    struct A(u8);
    struct B(u8);

    impl A {
        pub fn new() -> Self {
            unsafe {
                let x = A_COUNT;
                A_COUNT += 1;
                C_COUNT += x;
                A(x)
            }
        }
    }
    impl Drop for A {
        fn drop(&mut self) {
            unsafe {
                A_COUNT -= 1;
                C_COUNT -= self.0;
            }
        }
    }

    impl B {
        pub fn new() -> Self {
            unsafe {
                let x = B_COUNT;
                B_COUNT += 1;
                C_COUNT += x;
                B(x)
            }
        }
    }
    impl Drop for B {
        fn drop(&mut self) {
            unsafe {
                B_COUNT -= 1;
                C_COUNT -= self.0;
            }
        }
    }

    {
        let a0 = A::new();
        let a1 = A::new();
        let b0 = B::new();
        let b1 = B::new();
        let b2 = B::new();
        let s = String::from("Hello");

        let mut hvec = HVec::new();
        hvec.push(a0);
        hvec.push(b0);
        hvec.push(a1);
        hvec.push(b1);
        hvec.push(s);
        hvec.push(b2);
    }

    unsafe {
        let a_count: u8 = A_COUNT;
        let b_count: u8 = B_COUNT;
        let c_count: u8 = C_COUNT;
        assert_eq!(a_count, 0);
        assert_eq!(b_count, 0);
        assert_eq!(c_count, 0);
    }
}