mavlink_core/
bytes_mut.rs

1pub struct BytesMut<'a> {
2    data: &'a mut [u8],
3    len: usize,
4}
5
6impl<'a> BytesMut<'a> {
7    pub fn new(data: &'a mut [u8]) -> Self {
8        Self { data, len: 0 }
9    }
10
11    #[inline]
12    pub fn len(&self) -> usize {
13        self.len
14    }
15
16    #[inline]
17    pub fn is_empty(&self) -> bool {
18        self.len() == 0
19    }
20
21    #[inline]
22    pub fn remaining(&self) -> usize {
23        self.data.len() - self.len
24    }
25
26    #[inline]
27    fn check_remaining(&self, count: usize) {
28        assert!(
29            self.remaining() >= count,
30            "write buffer overflow; remaining {} bytes, try add {count} bytes",
31            self.remaining(),
32        );
33    }
34
35    #[inline]
36    pub fn put_slice(&mut self, src: &[u8]) {
37        self.check_remaining(src.len());
38
39        unsafe {
40            core::ptr::copy_nonoverlapping(src.as_ptr(), &mut self.data[self.len], src.len());
41        }
42        self.len += src.len();
43    }
44
45    #[inline]
46    pub fn put_u8(&mut self, val: u8) {
47        self.check_remaining(1);
48
49        self.data[self.len] = val;
50        self.len += 1;
51    }
52
53    #[inline]
54    pub fn put_i8(&mut self, val: i8) {
55        self.check_remaining(1);
56
57        self.data[self.len] = val as u8;
58        self.len += 1;
59    }
60
61    #[inline]
62    pub fn put_u16_le(&mut self, val: u16) {
63        const SIZE: usize = core::mem::size_of::<u16>();
64        self.check_remaining(SIZE);
65
66        let src = val.to_le_bytes();
67        self.data[self.len..self.len + SIZE].copy_from_slice(&src[..]);
68        self.len += SIZE;
69    }
70
71    #[inline]
72    pub fn put_i16_le(&mut self, val: i16) {
73        const SIZE: usize = core::mem::size_of::<i16>();
74        self.check_remaining(SIZE);
75
76        let src = val.to_le_bytes();
77        self.data[self.len..self.len + SIZE].copy_from_slice(&src[..]);
78        self.len += SIZE;
79    }
80
81    #[inline]
82    pub fn put_u24_le(&mut self, val: u32) {
83        const SIZE: usize = 3;
84        const MAX: u32 = 2u32.pow(24) - 1;
85
86        assert!(
87            val <= MAX,
88            "Attempted to put value that is too large for 24 bits, \
89	     attempted to push: {val}, max allowed: {MAX}",
90        );
91
92        let src = val.to_le_bytes();
93        self.data[self.len..self.len + SIZE].copy_from_slice(&src[..3]);
94        self.len += SIZE;
95    }
96
97    #[inline]
98    pub fn put_i24_le(&mut self, val: i32) {
99        const SIZE: usize = 3;
100        const MIN: i32 = 2i32.pow(23);
101        const MAX: i32 = 2i32.pow(23) - 1;
102
103        assert!(
104            val <= MAX,
105            "Attempted to put value that is too large for 24 bits, \
106	     attempted to push: {val}, max allowed: {MAX}",
107        );
108        assert!(
109            val >= MIN,
110            "Attempted to put value that is too negative for 24 bits, \
111	     attempted to push: {val}, min allowed: {MIN}",
112        );
113
114        let src = val.to_le_bytes();
115        self.data[self.len..self.len + SIZE].copy_from_slice(&src[..3]);
116        self.len += SIZE;
117    }
118
119    #[inline]
120    pub fn put_u32_le(&mut self, val: u32) {
121        const SIZE: usize = core::mem::size_of::<u32>();
122        self.check_remaining(SIZE);
123
124        let src = val.to_le_bytes();
125        self.data[self.len..self.len + SIZE].copy_from_slice(&src[..]);
126        self.len += SIZE;
127    }
128
129    #[inline]
130    pub fn put_i32_le(&mut self, val: i32) {
131        const SIZE: usize = core::mem::size_of::<i32>();
132        self.check_remaining(SIZE);
133
134        let src = val.to_le_bytes();
135        self.data[self.len..self.len + SIZE].copy_from_slice(&src[..]);
136        self.len += SIZE;
137    }
138
139    #[inline]
140    pub fn put_u64_le(&mut self, val: u64) {
141        const SIZE: usize = core::mem::size_of::<u64>();
142        self.check_remaining(SIZE);
143
144        let src = val.to_le_bytes();
145        self.data[self.len..self.len + SIZE].copy_from_slice(&src[..]);
146        self.len += SIZE;
147    }
148
149    #[inline]
150    pub fn put_i64_le(&mut self, val: i64) {
151        const SIZE: usize = core::mem::size_of::<i64>();
152        self.check_remaining(SIZE);
153
154        let src = val.to_le_bytes();
155        self.data[self.len..self.len + SIZE].copy_from_slice(&src[..]);
156        self.len += SIZE;
157    }
158
159    #[inline]
160    pub fn put_f32_le(&mut self, val: f32) {
161        const SIZE: usize = core::mem::size_of::<f32>();
162        self.check_remaining(SIZE);
163
164        let src = val.to_le_bytes();
165        self.data[self.len..self.len + SIZE].copy_from_slice(&src[..]);
166        self.len += SIZE;
167    }
168
169    #[inline]
170    pub fn put_f64_le(&mut self, val: f64) {
171        const SIZE: usize = core::mem::size_of::<f64>();
172        self.check_remaining(SIZE);
173
174        let src = val.to_le_bytes();
175        self.data[self.len..self.len + SIZE].copy_from_slice(&src[..]);
176        self.len += SIZE;
177    }
178}
mavlink_core/bytes_mut.rs

mavlink_core/
bytes_mut.rs
