darkomen 0.5.0

Warhammer: Dark Omen library and CLI in Rust
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

use std::io::{self, Read, Take};

enum ZeroRunsReaderState {
    Header,
    Literal,
    Repeat,
}

/// Reader that unpacks ZeroRuns format.
pub(crate) struct ZeroRunsReader<R: Read> {
    reader: Take<R>,
    state: ZeroRunsReaderState,
    count: usize,
}

impl<R: Read> ZeroRunsReader<R> {
    /// Wraps a reader.
    pub fn new(reader: R, length: u64) -> Self {
        Self {
            reader: reader.take(length),
            state: ZeroRunsReaderState::Header,
            count: 0,
        }
    }
}

impl<R: Read> Read for ZeroRunsReader<R> {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        while let ZeroRunsReaderState::Header = self.state {
            if self.reader.limit() == 0 {
                return Ok(0);
            }
            let mut header: [u8; 1] = [0];
            self.reader.read_exact(&mut header)?;
            let h = header[0] as i8;
            if h >= 0 {
                self.state = ZeroRunsReaderState::Literal;
                self.count = h as usize + 1;
            } else {
                self.state = ZeroRunsReaderState::Repeat;
                self.count = (-h) as usize;
            }
        }

        let length = buf.len().min(self.count);
        let actual = match self.state {
            ZeroRunsReaderState::Literal => self.reader.read(&mut buf[..length])?,
            ZeroRunsReaderState::Repeat => {
                for b in &mut buf[..length] {
                    *b = 0;
                }
                length
            }
            ZeroRunsReaderState::Header => unreachable!(),
        };

        self.count -= actual;
        if self.count == 0 {
            self.state = ZeroRunsReaderState::Header;
        }
        Ok(actual)
    }
}