cds 0.10.0

Collection of Optimized Data Structures
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

use crate::{arrayvec::ArrayVec, len::LengthType, mem::SpareMemoryPolicy};
use core::slice;

#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<L, SM, const C: usize> std::io::Write for ArrayVec<u8, C, L, SM>
where
    L: LengthType,
    SM: SpareMemoryPolicy<u8>,
{
    #[inline]
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        let len = self.spare_capacity().min(buf.len());
        unsafe { self.copy_from_slice_unchecked(slice::from_raw_parts(buf.as_ptr(), len)) };
        Ok(len)
    }

    #[inline]
    fn flush(&mut self) -> std::io::Result<()> {
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use crate::arrayvec::ArrayVec;
    use std::io::Write;

    #[test]
    fn test_io_write() {
        type A = ArrayVec<u8, 16>;
        let mut av = A::new();
        assert_eq!(av.write(b"thisisatest").unwrap(), 11);
        assert_eq!(av, b"thisisatest");
        assert_eq!(av.write(b"ofiowrite").unwrap(), 5);
        assert_eq!(av, b"thisisatestofiow");
    }

    #[test]
    fn test_io_write_empty() {
        type A = ArrayVec<u8, 16>;
        let mut av = A::new();
        assert_eq!(av.write(b"").unwrap(), 0);
        assert_eq!(av, []);
    }

    #[test]
    fn test_io_write_full() {
        type A = ArrayVec<u8, 5>;
        let mut av = A::new();
        assert_eq!(av.write(b"write").unwrap(), 5);
        assert_eq!(av, b"write");
    }

    #[test]
    fn test_io_write_flush() {
        type A = ArrayVec<u8, 5>;
        let mut av = A::new();
        assert!(av.flush().is_ok());
        assert_eq!(av.write(b"write").unwrap(), 5);
        assert!(av.flush().is_ok());
    }
}