1use crate::serde::error::DataError;
2use anyhow::{bail, ensure, Result};
3use serde::Deserialize;
4use std::convert::TryInto;
5use std::mem::size_of;
6use std::ops::Deref;
7
8pub trait ReadNumberFixed {
9 fn read(dr: &mut DataReader) -> Result<Self>
10 where
11 Self: Sized;
12}
13
14pub trait ReadNumberVar {
15 fn read(dr: &mut DataReader) -> Result<Self>
16 where
17 Self: Sized;
18}
19
20macro_rules! impl_read_number_fixed {
21 ($type:tt) => {
22 impl ReadNumberFixed for $type {
23 #[cfg(not(feature = "big_endian"))]
24 #[inline]
25 fn read(dr: &mut DataReader) -> Result<Self>
26 where
27 Self: Sized,
28 {
29 let size = size_of::<$type>();
30 ensure!(
31 size <= dr.len(),
32 "read fixed error len too min:dr:{} < {}",
33 dr.len(),
34 size
35 );
36 let v = $type::from_le_bytes(dr[..size].try_into()?);
37 dr.advance(size)?;
38 Ok(v)
39 }
40
41 #[cfg(feature = "big_endian")]
42 #[inline]
43 fn read(dr: &mut DataReader) -> Result<Self>
44 where
45 Self: Sized,
46 {
47 let size = size_of::<$type>();
48 ensure!(
49 size <= dr.len(),
50 "read fixed error len too min:dr:{} < {}",
51 dr.len(),
52 size
53 );
54 let v = $type::from_be_bytes(dr[..size].try_into()?);
55 dr.advance(size)?;
56 Ok(v)
57 }
58 }
59 };
60}
61
62impl ReadNumberFixed for bool {
63 #[inline]
64 fn read(dr: &mut DataReader) -> Result<Self>
65 where
66 Self: Sized,
67 {
68 let v = dr.read_fixed::<u8>()?;
69 if v == 0 {
70 Ok(false)
71 } else {
72 Ok(true)
73 }
74 }
75}
76
77impl_read_number_fixed!(u8);
78impl_read_number_fixed!(i8);
79impl_read_number_fixed!(u16);
80impl_read_number_fixed!(i16);
81impl_read_number_fixed!(u32);
82impl_read_number_fixed!(i32);
83impl_read_number_fixed!(u64);
84impl_read_number_fixed!(i64);
85impl_read_number_fixed!(i128);
86impl_read_number_fixed!(u128);
87impl_read_number_fixed!(f32);
88impl_read_number_fixed!(f64);
89
90impl ReadNumberVar for u16 {
91 #[inline]
92 fn read(dr: &mut DataReader) -> Result<Self>
93 where
94 Self: Sized,
95 {
96 let mut v = 0u16;
97 let mut offset = 0;
98 let mut shift = 0u8;
99 let mut b;
100 while shift < 16 {
101 ensure!(
102 offset != dr.len(),
103 "read var number,offset:{} > bytes length:{}",
104 offset,
105 dr.len()
106 );
107 b = dr[offset];
108 offset += 1;
109 v |= ((b & 0x7F) as u16) << shift;
110 if b & 0x80 == 0 {
111 dr.buff = &dr.buff[offset..];
112 return Ok(v);
113 }
114 shift += 7;
115 }
116 bail!("not read var number too end")
117 }
118}
119
120impl ReadNumberVar for i16 {
121 #[inline]
122 fn read(dr: &mut DataReader) -> Result<Self>
123 where
124 Self: Sized,
125 {
126 Ok(zig_zag_decode_i16(ReadNumberVar::read(dr)?))
127 }
128}
129
130impl ReadNumberVar for u32 {
131 #[inline]
132 fn read(dr: &mut DataReader) -> Result<Self>
133 where
134 Self: Sized,
135 {
136 let mut v = 0u32;
137 let mut offset = 0;
138 let mut shift = 0u8;
139 let mut b;
140 while shift < 32 {
141 ensure!(
142 offset != dr.len(),
143 "read var number,offset:{} > bytes length:{}",
144 offset,
145 dr.len()
146 );
147 b = dr[offset];
148 offset += 1;
149 v |= ((b & 0x7F) as u32) << shift;
150 if b & 0x80 == 0 {
151 dr.buff = &dr.buff[offset..];
152 return Ok(v);
153 }
154 shift += 7;
155 }
156 bail!("not read var number too end")
157 }
158}
159
160impl ReadNumberVar for i32 {
161 #[inline]
162 fn read(dr: &mut DataReader) -> Result<Self>
163 where
164 Self: Sized,
165 {
166 Ok(zig_zag_decode_i32(ReadNumberVar::read(dr)?))
167 }
168}
169
170impl ReadNumberVar for u64 {
171 #[inline]
172 fn read(dr: &mut DataReader) -> Result<Self>
173 where
174 Self: Sized,
175 {
176 let mut v = 0u64;
177 let mut offset = 0;
178 let mut shift = 0u8;
179 let mut b;
180 while shift < 64 {
181 ensure!(
182 offset != dr.len(),
183 "read var number,offset:{} > bytes length:{}",
184 offset,
185 dr.len()
186 );
187 b = dr[offset];
188 offset += 1;
189 v |= ((b & 0x7F) as u64) << shift;
190 if b & 0x80 == 0 {
191 dr.buff = &dr.buff[offset..];
192 return Ok(v);
193 }
194 shift += 7;
195 }
196 bail!("not read var number too end")
197 }
198}
199
200impl ReadNumberVar for i64 {
201 #[inline]
202 fn read(dr: &mut DataReader) -> Result<Self>
203 where
204 Self: Sized,
205 {
206 Ok(zig_zag_decode_i64(ReadNumberVar::read(dr)?))
207 }
208}
209
210#[inline(always)]
211fn zig_zag_decode_i16(v: u16) -> i16 {
212 ((v >> 1) as i16) ^ (-((v & 1) as i16))
213}
214#[inline(always)]
215fn zig_zag_decode_i32(v: u32) -> i32 {
216 ((v >> 1) as i32) ^ (-((v & 1) as i32))
217}
218#[inline(always)]
219fn zig_zag_decode_i64(v: u64) -> i64 {
220 ((v >> 1) as i64) ^ (-((v & 1) as i64))
221}
222
223#[derive(Debug)]
224pub struct DataReader<'a> {
225 pub(crate) buff: &'a [u8],
226 pub(crate) original_len: usize,
227 pub(crate) mode: u8,
228}
229
230impl<'a> From<&'a [u8]> for DataReader<'a> {
231 #[inline]
232 fn from(buff: &'a [u8]) -> Self {
233 DataReader {
234 buff,
235 original_len: buff.len(),
236 mode: 0,
237 }
238 }
239}
240
241impl<'a> Deref for DataReader<'a> {
242 type Target = &'a [u8];
243 #[inline]
244 fn deref(&self) -> &Self::Target {
245 &self.buff
246 }
247}
248
249impl<'a> AsRef<[u8]> for DataReader<'a> {
250 #[inline]
251 fn as_ref(&self) -> &[u8] {
252 self.buff
253 }
254}
255
256impl<'a> DataReader<'a> {
257 #[inline]
258 pub fn from<T: AsRef<[u8]> + ?Sized>(v: &'a T) -> Self {
259 let buff = v.as_ref();
260 DataReader {
261 original_len: buff.len(),
262 buff,
263 mode: 0,
264 }
265 }
266
267 #[inline]
268 pub fn deserialize<'de, D: Deserialize<'de>, T: AsRef<[u8]>>(
269 v: &'de T,
270 ) -> Result<D, DataError> {
271 let buff = v.as_ref();
272 D::deserialize(&mut DataReader {
273 original_len: buff.len(),
274 buff,
275 mode: 0,
276 })
277 }
278
279 #[inline]
280 pub fn advance(&mut self, cnt: usize) -> Result<()> {
281 ensure!(
282 self.len() >= cnt,
283 "advance error,cnt:{} > len:{}",
284 cnt,
285 self.len()
286 );
287 self.buff = &self.buff[cnt..];
288 Ok(())
289 }
290
291 #[inline]
292 pub fn offset(&self) -> usize {
293 self.original_len.wrapping_sub(self.buff.len())
294 }
295
296 #[inline]
297 pub fn reload(&mut self, buff: &'a [u8], original_len: usize) {
298 self.buff = buff;
299 self.original_len = original_len;
300 }
301
302 #[inline]
303 pub fn read_buff(&mut self, buff: &mut [u8]) -> Result<()> {
304 let size = buff.len();
305 ensure!(
306 self.len() >= size,
307 "read buff,buff too max,current:{} input:{}",
308 self.len(),
309 size
310 );
311 let (copy, current) = self.buff.split_at(size);
312 buff.copy_from_slice(copy);
313 self.buff = current;
314 Ok(())
315 }
316
317 #[inline]
318 pub fn read_var_str(&mut self) -> Result<&'a str> {
319 let len = self.read_var_integer::<u64>()? as usize;
320 ensure!(
321 len <= self.len(),
322 "read string size too big,{}>{}",
323 len,
324 self.len()
325 );
326 let (res, have) = self.buff.split_at(len);
327 self.buff = have;
328
329 cfg_if::cfg_if! {
330 if #[cfg(feature ="check_utf8")]{
331 Ok(std::str::from_utf8(res)?)
332 }else{
333 unsafe {
334 Ok(std::str::from_utf8_unchecked(res))
335 }
336 }
337 }
338 }
339
340 #[inline]
341 pub fn read_fixed_str(&mut self) -> Result<&'a str> {
342 let len = self.read_fixed::<u32>()? as usize;
343 ensure!(
344 len <= self.len(),
345 "read string size too big,{}>{}",
346 len,
347 self.len()
348 );
349 let (res, have) = self.buff.split_at(len);
350 self.buff = have;
351
352 cfg_if::cfg_if! {
353 if #[cfg(feature ="check_utf8")]{
354 Ok(std::str::from_utf8(res)?)
355 }else{
356 unsafe {
357 Ok(std::str::from_utf8_unchecked(res))
358 }
359 }
360 }
361 }
362
363 #[inline]
364 pub fn read_var_buf(&mut self) -> Result<&'a [u8]> {
365 let len = self.read_var_integer::<u64>()? as usize;
366 ensure!(
367 len <= self.len(),
368 "read string size too big,{}>{}",
369 len,
370 self.len()
371 );
372 let (res, have) = self.buff.split_at(len);
373 self.buff = have;
374 Ok(res)
375 }
376
377 #[inline]
378 pub fn read_fixed_buf(&mut self) -> Result<&'a [u8]> {
379 let len = self.read_fixed::<u32>()? as usize;
380 ensure!(
381 len <= self.len(),
382 "read string size too big,{}>{}",
383 len,
384 self.len()
385 );
386 let (res, have) = self.buff.split_at(len);
387 self.buff = have;
388 Ok(res)
389 }
390
391 #[inline]
392 pub fn read_fixed<T: ReadNumberFixed>(&mut self) -> Result<T> {
393 T::read(self)
394 }
395
396 #[inline]
397 pub fn read_var_integer<T: ReadNumberVar>(&mut self) -> Result<T> {
398 T::read(self)
399 }
400}