heapless 0.9.2

`static` friendly data structures that don't require dynamic memory allocation
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
71
72
73
74
75
76
77
78
79
80
81
82
83

//! Implementations of `bytes` traits for `heapless` types.

use crate::{
    len_type::LenType,
    vec::{VecInner, VecStorage},
};
use bytes::{buf::UninitSlice, BufMut};

unsafe impl<S: VecStorage<u8> + ?Sized, LenT: LenType> BufMut for VecInner<u8, LenT, S> {
    #[inline]
    fn remaining_mut(&self) -> usize {
        self.capacity() - self.len()
    }

    #[inline]
    unsafe fn advance_mut(&mut self, cnt: usize) {
        let len = self.len();
        let pos = len + cnt;
        if pos >= self.capacity() {
            panic!("Advance out of range");
        }
        self.set_len(pos);
    }

    #[inline]
    fn chunk_mut(&mut self) -> &mut UninitSlice {
        let len = self.len();
        let ptr = self.as_mut_ptr();
        unsafe { &mut UninitSlice::from_raw_parts_mut(ptr, self.capacity())[len..] }
    }
}

#[cfg(test)]
mod tests {
    use crate::{Vec, VecView};
    use bytes::BufMut;

    #[test]
    #[should_panic]
    fn buf_mut_advance_mut_out_of_bounds() {
        let mut vec: Vec<u8, 8> = Vec::new();
        unsafe { vec.advance_mut(9) };
    }

    #[test]
    fn buf_mut_remaining_mut() {
        let mut vec: Vec<u8, 8> = Vec::new();
        assert_eq!(vec.remaining_mut(), 8);
        vec.push(42).unwrap();
        assert_eq!(vec.remaining_mut(), 7);
    }

    #[test]
    fn buf_mut_chunk_mut() {
        let mut vec: Vec<u8, 8> = Vec::new();
        assert_eq!(vec.chunk_mut().len(), 8);
        unsafe { vec.advance_mut(1) };
        assert_eq!(vec.chunk_mut().len(), 7);
    }

    #[test]
    #[should_panic]
    fn buf_mut_advance_mut_out_of_bounds_view() {
        let vec: &mut VecView<u8, u8> = &mut Vec::<u8, 8, u8>::new();
        unsafe { vec.advance_mut(9) };
    }

    #[test]
    fn buf_mut_remaining_mut_view() {
        let vec: &mut VecView<u8, u8> = &mut Vec::<u8, 8, u8>::new();
        assert_eq!(vec.remaining_mut(), 8);
        vec.push(42).unwrap();
        assert_eq!(vec.remaining_mut(), 7);
    }

    #[test]
    fn buf_mut_chunk_mut_view() {
        let vec: &mut VecView<u8, u8> = &mut Vec::<u8, 8, u8>::new();
        assert_eq!(vec.chunk_mut().len(), 8);
        unsafe { vec.advance_mut(1) };
        assert_eq!(vec.chunk_mut().len(), 7);
    }
}