mirx 0.46.3

MIRX binary image format — flat & chunk-based container for ahead-of-time UI assets
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

#[derive(Clone, Copy, Debug)]
pub(super) enum BufferError {
    SizeOverflow,
    Truncated { offset: usize },
}

pub(super) struct Cursor<'a> {
    bytes: &'a [u8],
    pub(super) position: usize,
}
impl<'a> Cursor<'a> {
    pub(super) fn new(bytes: &'a [u8]) -> Self {
        Self { bytes, position: 0 }
    }
    pub(super) fn is_empty(&self) -> bool {
        self.position == self.bytes.len()
    }
    pub(super) fn take(&mut self, count: usize) -> Result<&'a [u8], BufferError> {
        let end = self
            .position
            .checked_add(count)
            .ok_or(BufferError::SizeOverflow)?;
        let bytes = self
            .bytes
            .get(self.position..end)
            .ok_or(BufferError::Truncated {
                offset: self.position,
            })?;
        self.position = end;
        Ok(bytes)
    }
    pub(super) fn byte(&mut self) -> Result<u8, BufferError> {
        Ok(self.take(1)?[0])
    }
}

pub(super) struct Emitter<'a> {
    pub(super) output: Option<&'a mut [u8]>,
    pub(super) position: usize,
}
impl Emitter<'_> {
    pub(super) fn count() -> Self {
        Self {
            output: None,
            position: 0,
        }
    }
    pub(super) fn put(&mut self, bytes: &[u8]) -> Result<(), BufferError> {
        let end = self
            .position
            .checked_add(bytes.len())
            .ok_or(BufferError::SizeOverflow)?;
        if let Some(output) = &mut self.output {
            output[self.position..end].copy_from_slice(bytes);
        }
        self.position = end;
        Ok(())
    }
}