1use {
2 std,
3 std::io::Read,
4
5 bite::Endianness,
6};
7
8
9
10pub trait BiteReadExpandedExt: Read {
11 #[inline]
12 fn read_u8(&mut self) -> Result<u8, std::io::Error> {
13 let mut data = [0; 1];
14 self.read_exact(&mut data)?;
15
16 let v = data[0];
17 Ok(v)
18 }
19
20 #[inline]
21 fn read_i8(&mut self) -> Result<i8, std::io::Error> {
22 let mut data = [0; 1];
23 self.read_exact(&mut data)?;
24
25 let v = data[0] as i8;
26 Ok(v)
27 }
28
29 #[inline]
30 fn read_u16<T: Endianness>(&mut self) -> Result<u16, std::io::Error> {
31 let mut data = [0; 2];
32 self.read_exact(&mut data)?;
33
34 let v = T::read_u16(&data);
35 Ok(v)
36 }
37
38 #[inline]
39 fn read_i16<T: Endianness>(&mut self) -> Result<i16, std::io::Error> {
40 let mut data = [0; 2];
41 self.read_exact(&mut data)?;
42
43 let v = T::read_i16(&data);
44 Ok(v)
45 }
46
47 #[inline]
48 fn read_u24<T: Endianness>(&mut self) -> Result<u32, std::io::Error> {
49 let mut data = [0; 4];
50 self.read_exact(&mut data)?;
51
52 let v = T::read_u24(&data);
53 Ok(v)
54 }
55
56 #[inline]
57 fn read_i24<T: Endianness>(&mut self) -> Result<i32, std::io::Error> {
58 let mut data = [0; 4];
59 self.read_exact(&mut data)?;
60
61 let v = T::read_i24(&data);
62 Ok(v)
63 }
64
65 #[inline]
66 fn read_u32<T: Endianness>(&mut self) -> Result<u32, std::io::Error> {
67 let mut data = [0; 4];
68 self.read_exact(&mut data)?;
69
70 let v = T::read_u32(&data);
71 Ok(v)
72 }
73
74 #[inline]
75 fn read_i32<T: Endianness>(&mut self) -> Result<i32, std::io::Error> {
76 let mut data = [0; 4];
77 self.read_exact(&mut data)?;
78
79 let v = T::read_i32(&data);
80 Ok(v)
81 }
82
83 #[inline]
84 fn read_u64<T: Endianness>(&mut self) -> Result<u64, std::io::Error> {
85 let mut data = [0; 8];
86 self.read_exact(&mut data)?;
87
88 let v = T::read_u64(&data);
89 Ok(v)
90 }
91
92 #[inline]
93 fn read_i64<T: Endianness>(&mut self) -> Result<i64, std::io::Error> {
94 let mut data = [0; 8];
95 self.read_exact(&mut data)?;
96
97 let v = T::read_i64(&data);
98 Ok(v)
99 }
100
101 #[inline]
102 fn read_u128<T: Endianness>(&mut self) -> Result<u128, std::io::Error> {
103 let mut data = [0; 16];
104 self.read_exact(&mut data)?;
105
106 let v = T::read_u128(&data);
107 Ok(v)
108 }
109
110 #[inline]
111 fn read_i128<T: Endianness>(&mut self) -> Result<i128, std::io::Error> {
112 let mut data = [0; 16];
113 self.read_exact(&mut data)?;
114
115 let v = T::read_i128(&data);
116 Ok(v)
117 }
118
119 #[inline]
120 fn read_uint<T: Endianness>(&mut self, bytes: usize) -> Result<u64, std::io::Error> {
121 let mut data = [0; 8];
122 self.read_exact(&mut data[..bytes])?;
123
124 let v = T::read_uint(&data[..bytes], bytes);
125 Ok(v)
126 }
127
128 #[inline]
129 fn read_int<T: Endianness>(&mut self, bytes: usize) -> Result<i64, std::io::Error> {
130 let mut data = [0; 8];
131 self.read_exact(&mut data[..bytes])?;
132
133 let v = T::read_int(&data[..bytes], bytes);
134 Ok(v)
135 }
136
137 #[inline]
138 fn read_uint128<T: Endianness>(&mut self, bytes: usize) -> Result<u128, std::io::Error> {
139 let mut data = [0; 16];
140 self.read_exact(&mut data[..bytes])?;
141
142 let v = T::read_uint128(&data[..bytes], bytes);
143 Ok(v)
144 }
145
146 #[inline]
147 fn read_int128<T: Endianness>(&mut self, bytes: usize) -> Result<i128, std::io::Error> {
148 let mut data = [0; 16];
149 self.read_exact(&mut data[..bytes])?;
150
151 let v = T::read_int128(&data[..bytes], bytes);
152 Ok(v)
153 }
154
155 #[inline]
156 fn read_f32<T: Endianness>(&mut self) -> Result<f32, std::io::Error> {
157 let mut data = [0; 4];
158 self.read_exact(&mut data)?;
159
160 let v = T::read_f32(&data);
161 Ok(v)
162 }
163
164 #[inline]
165 fn read_f64<T: Endianness>(&mut self) -> Result<f64, std::io::Error> {
166 let mut data = [0; 8];
167 self.read_exact(&mut data)?;
168
169 let v = T::read_f64(&data);
170 Ok(v)
171 }
172
173
174
175 #[inline]
176 fn read_slice_u16<T: Endianness>(&mut self, values: &mut [u16]) -> Result<(), std::io::Error> {
177 self.read_exact(unsafe { as_mutable_data(values) })?;
178
179 T::convert_slice_u16(values);
180 Ok(())
181 }
182
183 #[inline]
184 fn read_slice_i16<T: Endianness>(&mut self, values: &mut [i16]) -> Result<(), std::io::Error> {
185 self.read_exact(unsafe { as_mutable_data(values) })?;
186
187 T::convert_slice_i16(values);
188 Ok(())
189 }
190
191 #[inline]
192 fn read_slice_u32<T: Endianness>(&mut self, values: &mut [u32]) -> Result<(), std::io::Error> {
193 self.read_exact(unsafe { as_mutable_data(values) })?;
194
195 T::convert_slice_u32(values);
196 Ok(())
197 }
198
199 #[inline]
200 fn read_slice_i32<T: Endianness>(&mut self, values: &mut [i32]) -> Result<(), std::io::Error> {
201 self.read_exact(unsafe { as_mutable_data(values) })?;
202
203 T::convert_slice_i32(values);
204 Ok(())
205 }
206
207 #[inline]
208 fn read_slice_u64<T: Endianness>(&mut self, values: &mut [u64]) -> Result<(), std::io::Error> {
209 self.read_exact(unsafe { as_mutable_data(values) })?;
210
211 T::convert_slice_u64(values);
212 Ok(())
213 }
214
215 #[inline]
216 fn read_slice_i64<T: Endianness>(&mut self, values: &mut [i64]) -> Result<(), std::io::Error> {
217 self.read_exact(unsafe { as_mutable_data(values) })?;
218
219 T::convert_slice_i64(values);
220 Ok(())
221 }
222
223 #[inline]
224 fn read_slice_u128<T: Endianness>(&mut self, values: &mut [u128]) -> Result<(), std::io::Error> {
225 self.read_exact(unsafe { as_mutable_data(values) })?;
226
227 T::convert_slice_u128(values);
228 Ok(())
229 }
230
231 #[inline]
232 fn read_slice_i128<T: Endianness>(&mut self, values: &mut [i128]) -> Result<(), std::io::Error> {
233 self.read_exact(unsafe { as_mutable_data(values) })?;
234
235 T::convert_slice_i128(values);
236 Ok(())
237 }
238
239 #[inline]
240 fn read_slice_f32<T: Endianness>(&mut self, values: &mut [f32]) -> Result<(), std::io::Error> {
241 self.read_exact(unsafe { as_mutable_data(values) })?;
242
243 T::convert_slice_f32(values);
244 Ok(())
245 }
246
247 #[inline]
248 fn read_slice_f64<T: Endianness>(&mut self, values: &mut [f64]) -> Result<(), std::io::Error> {
249 self.read_exact(unsafe { as_mutable_data(values) })?;
250
251 T::convert_slice_f64(values);
252 Ok(())
253 }
254
255
256
257 #[inline]
258 fn read_framed<T: Endianness>(&mut self) -> Result<Vec<u8>, std::io::Error> {
259 self.read_framed_max::<T>(std::usize::MAX)
260 }
261
262 #[inline]
263 fn read_framed_max<T: Endianness>(&mut self, maximum: usize) -> Result<Vec<u8>, std::io::Error> {
264 let length = match self.read_u32::<T>()? as usize {
265 x if x <= maximum => x,
266 _ => return Err(std::io::ErrorKind::InvalidData.into()),
267 };
268
269 unsafe {
270 let mut data = Vec::with_capacity(length);
271 let slice = std::slice::from_raw_parts_mut(data.as_mut_ptr(), length);
272
273 self.read_exact(slice)?;
274 data.set_len(length);
275
276 Ok(data)
277 }
278 }
279}
280
281impl<T> BiteReadExpandedExt for T where T: std::io::Read + ?Sized { }
282
283
284
285unsafe fn as_mutable_data<T: Copy>(data: &mut [T]) -> &mut [u8] {
286 let source = data.as_mut_ptr() as *mut u8;
287 let length = std::mem::size_of::<T>() * data.len();
288
289 std::slice::from_raw_parts_mut(source, length)
290}