rc-zip 5.1.3

An I/O-agnostic implementation of the zip file format
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

use std::cmp;

use rc_zip::{
    corpus,
    fsm::{ArchiveFsm, FsmResult},
};

#[test]
fn state_machine() {
    corpus::install_test_subscriber();

    let cases = corpus::test_cases();
    let case = cases.iter().find(|x| x.name == "zip64.zip").unwrap();
    let bytes = case.bytes();

    let mut fsm = ArchiveFsm::new(bytes.len() as u64);

    let archive = 'read_zip: loop {
        if let Some(offset) = fsm.wants_read() {
            let increment = 128usize;
            let offset = offset as usize;
            let slice = if offset + increment > bytes.len() {
                &bytes[offset..]
            } else {
                &bytes[offset..offset + increment]
            };

            let len = cmp::min(slice.len(), fsm.space().len());
            fsm.space()[..len].copy_from_slice(&slice[..len]);
            match len {
                0 => panic!("EOF!"),
                read_bytes => {
                    fsm.fill(read_bytes);
                }
            }
        }

        fsm = match fsm.process() {
            Ok(res) => match res {
                FsmResult::Continue(fsm) => fsm,
                FsmResult::Done(archive) => break 'read_zip archive,
            },
            Err(err) => {
                panic!("{}", err)
            }
        }
    };

    // cool, we have the archive
    let _ = archive;
}