refpack 2.0.0

A crate providing compression/decompression for the RefPack compression format, utilized by many early 2000s EA games
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

////////////////////////////////////////////////////////////////////////////////
// This Source Code Form is subject to the terms of the Mozilla Public         /
// License, v. 2.0. If a copy of the MPL was not distributed with this         /
// file, You can obtain one at https://mozilla.org/MPL/2.0/.                   /
//                                                                             /
////////////////////////////////////////////////////////////////////////////////

use std::io::{Read, Seek};
use std::marker::PhantomData;

use crate::data::control::mode::Mode;
use crate::data::control::Control;

/// Iterator to to read a byte reader into a sequence of controls that can be iterated through
pub struct Iter<'a, R: Read + Seek, M: Mode> {
    reader: &'a mut R,
    reached_stop: bool,
    mode: PhantomData<M>,
}

impl<'a, R: Read + Seek, M: Mode> Iter<'a, R, M> {
    pub fn new(reader: &'a mut R) -> Iter<'a, R, M> {
        Iter::<'a, R, M> {
            reader,
            reached_stop: false,
            mode: PhantomData,
        }
    }
}

impl<'a, R: Read + Seek, M: Mode> Iterator for Iter<'a, R, M> {
    type Item = Control;

    fn next(&mut self) -> Option<Self::Item> {
        if self.reached_stop {
            None
        } else {
            Control::read::<M>(self.reader).ok().map(|control| {
                if control.command.is_stop() {
                    self.reached_stop = true;
                }
                control
            })
        }
    }
}

#[cfg(test)]
mod test {
    use std::io::Cursor;

    use proptest::prop_assert_eq;
    use test_strategy::proptest;

    use super::*;
    use crate::data::control::mode::Reference;
    use crate::data::control::tests::generate_valid_control_sequence;
    use crate::data::control::Control;

    #[proptest]
    fn test_control_iterator(
        #[strategy(generate_valid_control_sequence::<Reference>(500))] input: Vec<Control>,
    ) {
        let expected = input.clone();
        let buf = input
            .iter()
            .map(|control: &Control| -> Vec<u8> {
                let mut buf = Cursor::new(vec![]);
                control.write::<Reference>(&mut buf).unwrap();
                buf.into_inner()
            })
            .fold(vec![], |mut acc, mut buf| {
                acc.append(&mut buf);
                acc
            });

        let mut cursor = Cursor::new(buf);
        let out: Vec<Control> = Iter::<_, Reference>::new(&mut cursor).collect();

        prop_assert_eq!(out, expected);
    }
}