zune-core 0.5.1

Core utilities for image processing in the zune family of crates
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

// We cannot use the below impls and std ones because we'll re-implement the
// same trait fot &[u8] which is blanketed by write. Ending up with two separate implementations
#![cfg(not(feature = "std"))]
use crate::bytestream::{ZByteIoError, ZByteWriterTrait};

impl ZByteWriterTrait for &mut [u8] {
    fn write_bytes(&mut self, buf: &[u8]) -> Result<usize, ZByteIoError> {
        // got from the write of std
        let amt = core::cmp::min(buf.len(), self.len());
        let (a, b) = core::mem::take(self).split_at_mut(amt);
        a.copy_from_slice(&buf[..amt]);
        *self = b;
        Ok(amt)
    }

    fn write_all_bytes(&mut self, buf: &[u8]) -> Result<(), ZByteIoError> {
        if buf.len() > self.len() {
            return Err(ZByteIoError::NotEnoughBuffer(self.len(), buf.len()));
        }
        let amt = core::cmp::min(buf.len(), self.len());
        let (a, b) = core::mem::take(self).split_at_mut(amt);
        a.copy_from_slice(&buf[..amt]);
        *self = b;

        Ok(())
    }

    fn write_const_bytes<const N: usize>(&mut self, buf: &[u8; N]) -> Result<(), ZByteIoError> {
        if N > self.len() {
            return Err(ZByteIoError::NotEnoughBuffer(self.len(), N));
        }
        let amt = core::cmp::min(buf.len(), self.len());
        let (a, b) = core::mem::take(self).split_at_mut(amt);
        a.copy_from_slice(&buf[..amt]);
        *self = b;
        Ok(())
    }

    fn flush_bytes(&mut self) -> Result<(), ZByteIoError> {
        Ok(())
    }
    fn reserve_capacity(&mut self, _: usize) -> Result<(), ZByteIoError> {
        // can't really pre-allocate anything here
        Ok(())
    }
}

impl ZByteWriterTrait for &mut alloc::vec::Vec<u8> {
    fn write_bytes(&mut self, buf: &[u8]) -> Result<usize, ZByteIoError> {
        self.extend_from_slice(buf);
        Ok(buf.len())
    }

    fn write_all_bytes(&mut self, buf: &[u8]) -> Result<(), ZByteIoError> {
        self.extend_from_slice(buf);
        Ok(())
    }

    fn write_const_bytes<const N: usize>(&mut self, buf: &[u8; N]) -> Result<(), ZByteIoError> {
        self.extend_from_slice(buf);
        Ok(())
    }
    fn flush_bytes(&mut self) -> Result<(), ZByteIoError> {
        Ok(())
    }
    fn reserve_capacity(&mut self, size: usize) -> Result<(), ZByteIoError> {
        self.reserve(size);
        Ok(())
    }
}