buffered 0.1.0

Implement SOA for independently buffered streams
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

pub trait Buffered {
    type Fields;
    fn push_field(&mut self, field: Self::Fields) -> Result<(), Self::Fields>;
}

#[cfg(test)]
mod test {
    use super::*;
    use buffered_derive::buffered;

    #[derive(Debug)]
    #[buffered]
    struct Josh {
        x: u32,
        y: u8,
        z: f32
    }

    #[test]
    fn push_1() {
        let mut x = JoshBuffered::new();

        x.push_field(JoshFields::X(1)).expect("Failed to push X");
        x.push_field(JoshFields::Y(100)).expect("Failed to push Y");
        x.push_field(JoshFields::Z(10.0)).expect("Failed to push Y");

        assert_eq!(x.x, vec![1]);
        assert_eq!(x.y, vec![100]);
        assert_eq!(x.z, vec![10.0]);
    }

    #[test]
    fn push_100() {
        let mut buf = JoshBuffered::new();

        let xs: Vec<_> = (0..100).map(|x| x * x).collect();
        let ys: Vec<_> = (0..100).map(|x| x + x).collect();

        xs.iter()
            .for_each(|x| buf.push_field(JoshFields::X(*x)).expect("Failed to push X"));
        ys.iter()
            .for_each(|x| buf.push_field(JoshFields::Y(*x)).expect("Failed to push Y"));

        assert_eq!(buf.x, xs);
        assert_eq!(buf.y, ys);
    }
}