tars_stream/
tars_decoder.rs

1use bytes::{Buf, Bytes, IntoBuf};
2use std::collections::BTreeMap;
3use std::mem;
4
5use errors::DecodeErr;
6use tars_trait::{EnumFromI32, EnumToI32, StructFromTars};
7use tars_type::TarsTypeMark;
8use tars_type::TarsTypeMark::*;
9
10#[derive(Debug)]
11pub struct TarsDecoder {
12    buf: Bytes,
13    pos: usize,
14}
15#[derive(Debug)]
16pub struct Head {
17    tag: u8,
18    tars_type: TarsTypeMark,
19    len: u8,
20}
21
22impl TarsDecoder {
23    pub fn new() -> TarsDecoder {
24        TarsDecoder {
25            buf: Bytes::new(),
26            pos: 0,
27        }
28    }
29
30    pub fn individual_decode<T>(buf: &Bytes) -> Result<T, DecodeErr>
31    where
32        T: DecodeTars,
33    {
34        let mut decoder = TarsDecoder::from(buf);
35        T::_decode(&mut decoder, 0)
36    }
37
38    #[inline]
39    fn return_error_if_required_not_found<T>(
40        e: DecodeErr,
41        is_require: bool,
42        default_value: T,
43    ) -> Result<T, DecodeErr> {
44        match e {
45            // field 不存在，若为 require，返回异常，否则为 optional, 返回默认值
46            DecodeErr::TarsTagNotFoundErr => if is_require {
47                Err(e)
48            } else {
49                Ok(default_value)
50            },
51            _ => Err(e),
52        }
53    }
54
55    fn remaining(&self) -> usize {
56        self.buf.len() - self.pos
57    }
58
59    fn has_remaining(&self) -> bool {
60        self.remaining() > 0
61    }
62
63    fn current_pos(&self) -> usize {
64        self.pos
65    }
66
67    fn set_pos(&mut self, pos: usize) -> Result<(), DecodeErr> {
68        if pos > self.buf.len() {
69            Err(DecodeErr::NoEnoughDataErr)
70        } else {
71            self.pos = pos;
72            Ok(())
73        }
74    }
75
76    fn advance(&mut self, cnt: usize) -> Result<(), DecodeErr> {
77        if self.remaining() < cnt {
78            Err(DecodeErr::NoEnoughDataErr)
79        } else {
80            self.pos += cnt;
81            Ok(())
82        }
83    }
84
85    fn take_then_advance(&mut self, size: usize) -> Result<Bytes, DecodeErr> {
86        if self.remaining() < size {
87            Err(DecodeErr::NoEnoughDataErr)
88        } else {
89            let pos = self.current_pos();
90            let b = self.buf.slice(pos, pos + size);
91            self.pos += size;
92            Ok(b)
93        }
94    }
95
96    fn skip_to_tag(&mut self, tag: u8) -> Result<Head, DecodeErr> {
97        let mut result: Option<Head> = None;
98        // 记录当前位置
99        let before_pos = self.current_pos();
100        while self.has_remaining() {
101            let head = self.take_head()?;
102            if head.tag == tag && head.tars_type != EnStructEnd {
103                result = Some(head);
104                break;
105            } else {
106                self.skip_field(head.tars_type)?;
107            }
108        }
109        match result {
110            Some(h) => Ok(h),
111            None => {
112                // tag查找失败，恢复至tag查询前位置
113                self.set_pos(before_pos)?;
114                Err(DecodeErr::TarsTagNotFoundErr)
115            }
116        }
117    }
118
119    fn take_head(&mut self) -> Result<Head, DecodeErr> {
120        if self.remaining() < 1 {
121            Err(DecodeErr::NoEnoughDataErr)
122        } else {
123            let mut buf = self.take_then_advance(1)?.into_buf();
124            let b = buf.get_u8();
125            let tars_type = b & 0x0f;
126            let mut tag = (b & 0xf0) >> 4;
127            let len = if tag < 15 {
128                1
129            } else {
130                let mut buf = self.take_then_advance(1)?.into_buf();
131                tag = buf.get_u8();
132                2
133            };
134            Ok(Head {
135                tag,
136                len,
137                tars_type: TarsTypeMark::from(tars_type),
138            })
139        }
140    }
141
142    fn skip_field(&mut self, tars_type: TarsTypeMark) -> Result<(), DecodeErr> {
143        match tars_type {
144            EnInt8 => self.advance(1),
145            EnInt16 => self.advance(2),
146            EnInt32 => self.advance(4),
147            EnInt64 => self.advance(8),
148            EnFloat => self.advance(4),
149            EnDouble => self.advance(8),
150            EnString1 => self.skip_string1_field(),
151            EnString4 => self.skip_string4_field(),
152            EnMaps => self.skip_map_field(),
153            EnList => self.skip_list_field(),
154            EnStructBegin => self.skip_struct_field(),
155            EnStructEnd => Ok(()),
156            EnZero => Ok(()),
157            EnSimplelist => self.skip_simple_list_field(),
158        }
159    }
160
161    fn skip_string1_field(&mut self) -> Result<(), DecodeErr> {
162        let mut buf = self.take_then_advance(1)?.into_buf();
163        let size = buf.get_u8() as usize;
164        self.advance(size)
165    }
166
167    fn skip_string4_field(&mut self) -> Result<(), DecodeErr> {
168        let mut buf = self.take_then_advance(4)?.into_buf();
169        let size = buf.get_u32_be() as usize;
170        self.advance(size)
171    }
172
173    fn skip_map_field(&mut self) -> Result<(), DecodeErr> {
174        let ele_size = self.read_int32(0, true, 0)? as usize;
175        for _ in 0..ele_size * 2 {
176            let head = self.take_head()?;
177            self.skip_field(head.tars_type)?;
178        }
179        Ok(())
180    }
181
182    fn skip_list_field(&mut self) -> Result<(), DecodeErr> {
183        let ele_size = self.read_int32(0, true, 0)? as usize;
184        for _ in 0..ele_size {
185            let head = self.take_head()?;
186            self.skip_field(head.tars_type)?;
187        }
188        Ok(())
189    }
190
191    fn skip_simple_list_field(&mut self) -> Result<(), DecodeErr> {
192        let _head = self.take_head()?; // consume header (list type)
193        let size = self.read_int32(0, true, 0)? as usize;
194        self.advance(size)
195    }
196
197    fn skip_struct_field(&mut self) -> Result<(), DecodeErr> {
198        let mut head = self.take_head()?;
199        loop {
200            match head.tars_type {
201                EnStructEnd => break,
202                _ => {
203                    self.skip_field(head.tars_type)?;
204                    head = self.take_head()?;
205                }
206            }
207        }
208        Ok(())
209    }
210}
211
212impl<'a> From<&'a [u8]> for TarsDecoder {
213    fn from(buf: &'a [u8]) -> Self {
214        let b = Bytes::from(buf);
215        TarsDecoder { buf: b, pos: 0 }
216    }
217}
218
219impl<'a> From<&'a Bytes> for TarsDecoder {
220    fn from(buf: &'a Bytes) -> Self {
221        let b = buf.clone();
222        TarsDecoder { buf: b, pos: 0 }
223    }
224}
225
226impl From<Vec<u8>> for TarsDecoder {
227    fn from(buf: Vec<u8>) -> Self {
228        let b = Bytes::from(buf);
229        TarsDecoder { buf: b, pos: 0 }
230    }
231}
232
233pub trait TarsDecodeNormalTrait {
234    fn read_int8(&mut self, tag: u8, is_require: bool, default_value: i8) -> Result<i8, DecodeErr>;
235    fn read_boolean(
236        &mut self,
237        tag: u8,
238        is_require: bool,
239        default_value: bool,
240    ) -> Result<bool, DecodeErr>;
241
242    fn read_int16(
243        &mut self,
244        tag: u8,
245        is_require: bool,
246        default_value: i16,
247    ) -> Result<i16, DecodeErr>;
248
249    fn read_int32(
250        &mut self,
251        tag: u8,
252        is_require: bool,
253        default_value: i32,
254    ) -> Result<i32, DecodeErr>;
255
256    fn read_int64(
257        &mut self,
258        tag: u8,
259        is_require: bool,
260        default_value: i64,
261    ) -> Result<i64, DecodeErr>;
262
263    fn read_uint8(&mut self, tag: u8, is_require: bool, default_value: u8)
264        -> Result<u8, DecodeErr>;
265
266    fn read_uint16(
267        &mut self,
268        tag: u8,
269        is_require: bool,
270        default_value: u16,
271    ) -> Result<u16, DecodeErr>;
272
273    fn read_uint32(
274        &mut self,
275        tag: u8,
276        is_require: bool,
277        default_value: u32,
278    ) -> Result<u32, DecodeErr>;
279
280    fn read_float(
281        &mut self,
282        tag: u8,
283        is_require: bool,
284        default_value: f32,
285    ) -> Result<f32, DecodeErr>;
286
287    fn read_double(
288        &mut self,
289        tag: u8,
290        is_require: bool,
291        default_value: f64,
292    ) -> Result<f64, DecodeErr>;
293
294    fn read_string(
295        &mut self,
296        tag: u8,
297        is_require: bool,
298        default_value: String,
299    ) -> Result<String, DecodeErr>;
300
301    fn read_bytes(
302        &mut self,
303        tag: u8,
304        is_require: bool,
305        default_value: Bytes,
306    ) -> Result<Bytes, DecodeErr>;
307
308    fn read_map<K, V>(
309        &mut self,
310        tag: u8,
311        is_require: bool,
312        default_value: BTreeMap<K, V>,
313    ) -> Result<BTreeMap<K, V>, DecodeErr>
314    where
315        K: DecodeTars + Ord,
316        V: DecodeTars;
317
318    fn read_enum<T>(&mut self, tag: u8, is_require: bool, default_value: T) -> Result<T, DecodeErr>
319    where
320        T: EnumFromI32 + EnumToI32;
321
322    fn read_struct<T>(
323        &mut self,
324        tag: u8,
325        is_require: bool,
326        default_value: T,
327    ) -> Result<T, DecodeErr>
328    where
329        T: StructFromTars;
330}
331
332pub trait TarsDecodeListTrait<T>
333where
334    T: DecodeTars,
335{
336    fn read_list(
337        &mut self,
338        tag: u8,
339        is_require: bool,
340        default_value: Vec<T>,
341    ) -> Result<Vec<T>, DecodeErr>;
342}
343
344impl TarsDecodeNormalTrait for TarsDecoder {
345    fn read_int8(&mut self, tag: u8, is_require: bool, default_value: i8) -> Result<i8, DecodeErr> {
346        match self.skip_to_tag(tag) {
347            Ok(head) => match head.tars_type {
348                // tag 查找成功
349                EnZero => Ok(0),
350                EnInt8 => {
351                    let mut buf = self.take_then_advance(1)?.into_buf();
352                    Ok(buf.get_i8())
353                }
354                _ => Err(DecodeErr::MisMatchTarsTypeErr),
355            },
356            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
357        }
358    }
359
360    fn read_boolean(
361        &mut self,
362        tag: u8,
363        is_require: bool,
364        default_value: bool,
365    ) -> Result<bool, DecodeErr> {
366        self.read_int8(tag, is_require, default_value as i8)
367            .map(|i| i != 0)
368    }
369
370    fn read_int16(
371        &mut self,
372        tag: u8,
373        is_require: bool,
374        default_value: i16,
375    ) -> Result<i16, DecodeErr> {
376        match self.skip_to_tag(tag) {
377            Ok(head) => match head.tars_type {
378                EnZero => Ok(0),
379                EnInt8 => {
380                    let mut buf = self.take_then_advance(1)?.into_buf();
381                    Ok(i16::from(buf.get_i8()))
382                }
383                EnInt16 => {
384                    let mut buf = self.take_then_advance(2)?.into_buf();
385                    Ok(buf.get_i16_be())
386                }
387                _ => Err(DecodeErr::MisMatchTarsTypeErr),
388            },
389            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
390        }
391    }
392
393    fn read_int32(
394        &mut self,
395        tag: u8,
396        is_require: bool,
397        default_value: i32,
398    ) -> Result<i32, DecodeErr> {
399        match self.skip_to_tag(tag) {
400            Ok(head) => match head.tars_type {
401                EnZero => Ok(0),
402                EnInt8 => {
403                    let mut buf = self.take_then_advance(1)?.into_buf();
404                    Ok(i32::from(buf.get_i8()))
405                }
406                EnInt16 => {
407                    let mut buf = self.take_then_advance(2)?.into_buf();
408                    Ok(i32::from(buf.get_i16_be()))
409                }
410                EnInt32 => {
411                    let mut buf = self.take_then_advance(4)?.into_buf();
412                    Ok(buf.get_i32_be())
413                }
414                _ => Err(DecodeErr::MisMatchTarsTypeErr),
415            },
416            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
417        }
418    }
419
420    fn read_int64(
421        &mut self,
422        tag: u8,
423        is_require: bool,
424        default_value: i64,
425    ) -> Result<i64, DecodeErr> {
426        match self.skip_to_tag(tag) {
427            Ok(head) => match head.tars_type {
428                EnZero => Ok(0),
429                EnInt8 => {
430                    let mut buf = self.take_then_advance(1)?.into_buf();
431                    Ok(i64::from(buf.get_i8()))
432                }
433                EnInt16 => {
434                    let mut buf = self.take_then_advance(2)?.into_buf();
435                    Ok(i64::from(buf.get_i16_be()))
436                }
437                EnInt32 => {
438                    let mut buf = self.take_then_advance(4)?.into_buf();
439                    Ok(i64::from(buf.get_i32_be()))
440                }
441                EnInt64 => {
442                    let mut buf = self.take_then_advance(8)?.into_buf();
443                    Ok(buf.get_i64_be())
444                }
445                _ => Err(DecodeErr::MisMatchTarsTypeErr),
446            },
447            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
448        }
449    }
450
451    fn read_uint8(
452        &mut self,
453        tag: u8,
454        is_require: bool,
455        default_value: u8,
456    ) -> Result<u8, DecodeErr> {
457        self.read_int16(tag, is_require, default_value as i16)
458            .map(|i| i as u8)
459    }
460
461    fn read_uint16(
462        &mut self,
463        tag: u8,
464        is_require: bool,
465        default_value: u16,
466    ) -> Result<u16, DecodeErr> {
467        self.read_int32(tag, is_require, default_value as i32)
468            .map(|i| i as u16)
469    }
470
471    fn read_uint32(
472        &mut self,
473        tag: u8,
474        is_require: bool,
475        default_value: u32,
476    ) -> Result<u32, DecodeErr> {
477        self.read_int64(tag, is_require, default_value as i64)
478            .map(|i| i as u32)
479    }
480
481    fn read_float(
482        &mut self,
483        tag: u8,
484        is_require: bool,
485        default_value: f32,
486    ) -> Result<f32, DecodeErr> {
487        match self.skip_to_tag(tag) {
488            Ok(head) => match head.tars_type {
489                EnZero => Ok(0.0),
490                EnFloat => {
491                    let mut buf = self.take_then_advance(4)?.into_buf();
492                    Ok(buf.get_f32_be())
493                }
494                _ => Err(DecodeErr::MisMatchTarsTypeErr),
495            },
496            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
497        }
498    }
499
500    fn read_double(
501        &mut self,
502        tag: u8,
503        is_require: bool,
504        default_value: f64,
505    ) -> Result<f64, DecodeErr> {
506        match self.skip_to_tag(tag) {
507            Ok(head) => match head.tars_type {
508                EnZero => Ok(0.0),
509                EnDouble => {
510                    let mut buf = self.take_then_advance(8)?.into_buf();
511                    Ok(buf.get_f64_be())
512                }
513                _ => Err(DecodeErr::MisMatchTarsTypeErr),
514            },
515            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
516        }
517    }
518
519    fn read_string(
520        &mut self,
521        tag: u8,
522        is_require: bool,
523        default_value: String,
524    ) -> Result<String, DecodeErr> {
525        match self.skip_to_tag(tag) {
526            Ok(head) => match head.tars_type {
527                EnString1 => {
528                    let mut size_buf = self.take_then_advance(1)?.into_buf();
529                    let size = size_buf.get_u8() as usize;
530                    let field_buf = self.take_then_advance(size)?.into_buf();
531                    let cow = String::from_utf8_lossy(field_buf.bytes());
532                    Ok(String::from(cow))
533                }
534                EnString4 => {
535                    let mut size_buf = self.take_then_advance(4)?.into_buf();
536                    let size = size_buf.get_u32_be() as usize;
537                    let field_buf = self.take_then_advance(size)?.into_buf();
538                    let cow = String::from_utf8_lossy(field_buf.bytes());
539                    Ok(String::from(cow))
540                }
541                _ => Err(DecodeErr::MisMatchTarsTypeErr),
542            },
543            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
544        }
545    }
546
547    fn read_bytes(
548        &mut self,
549        tag: u8,
550        is_require: bool,
551        default_value: Bytes,
552    ) -> Result<Bytes, DecodeErr> {
553        match self.skip_to_tag(tag) {
554            Ok(head) => match head.tars_type {
555                EnSimplelist => {
556                    let head = self.take_head()?;
557                    match head.tars_type {
558                        EnInt8 | EnInt16 | EnInt32 => {
559                            let size = self.read_int32(0, true, 0)? as usize;
560                            self.take_then_advance(size)
561                        }
562                        _ => Err(DecodeErr::WrongSimpleListTarsTypeErr),
563                    }
564                }
565                _ => Err(DecodeErr::MisMatchTarsTypeErr),
566            },
567            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
568        }
569    }
570
571    fn read_map<K, V>(
572        &mut self,
573        tag: u8,
574        is_require: bool,
575        default_value: BTreeMap<K, V>,
576    ) -> Result<BTreeMap<K, V>, DecodeErr>
577    where
578        K: DecodeTars + Ord,
579        V: DecodeTars,
580    {
581        match self.skip_to_tag(tag) {
582            Ok(head) => match head.tars_type {
583                EnMaps => {
584                    let size = self.read_int32(0, true, 0)? as usize;
585                    let mut m = BTreeMap::new();
586                    for _ in 0..size {
587                        let key = K::_decode(self, 0)?;
588                        let value = V::_decode(self, 1)?;
589                        m.insert(key, value);
590                    }
591                    Ok(m)
592                }
593                _ => Err(DecodeErr::MisMatchTarsTypeErr),
594            },
595            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
596        }
597    }
598
599    fn read_enum<T>(&mut self, tag: u8, is_require: bool, default_value: T) -> Result<T, DecodeErr>
600    where
601        T: EnumFromI32 + EnumToI32,
602    {
603        let i = self.read_int32(tag, is_require, default_value._to_i32())?;
604        T::_from_i32(i)
605    }
606
607    fn read_struct<T>(
608        &mut self,
609        tag: u8,
610        is_require: bool,
611        default_value: T,
612    ) -> Result<T, DecodeErr>
613    where
614        T: StructFromTars,
615    {
616        match self.skip_to_tag(tag) {
617            Ok(head) => match head.tars_type {
618                EnStructBegin => T::_decode_from(self),
619                _ => Err(DecodeErr::MisMatchTarsTypeErr),
620            },
621            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
622        }
623    }
624}
625
626impl<T> TarsDecodeListTrait<T> for TarsDecoder
627where
628    T: DecodeTars,
629{
630    default fn read_list(
631        &mut self,
632        tag: u8,
633        is_require: bool,
634        default_value: Vec<T>,
635    ) -> Result<Vec<T>, DecodeErr> {
636        match self.skip_to_tag(tag) {
637            Ok(head) => match head.tars_type {
638                EnList => {
639                    let size = self.read_int32(0, true, 0)? as usize;
640                    let mut v = vec![];
641                    for _ in 0..size {
642                        let ele = T::_decode(self, 0)?;
643                        v.push(ele);
644                    }
645                    Ok(v)
646                }
647                _ => Err(DecodeErr::MisMatchTarsTypeErr),
648            },
649            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
650        }
651    }
652}
653
654impl TarsDecodeListTrait<i8> for TarsDecoder {
655    fn read_list(
656        &mut self,
657        tag: u8,
658        is_require: bool,
659        default_value: Vec<i8>,
660    ) -> Result<Vec<i8>, DecodeErr> {
661        match self.skip_to_tag(tag) {
662            Ok(head) => match head.tars_type {
663                EnSimplelist => {
664                    let head = self.take_head()?;
665                    match head.tars_type {
666                        EnInt8 | EnInt16 | EnInt32 => {
667                            let size = self.read_int32(0, true, 0)? as usize;
668                            Ok(unsafe { mem::transmute(self.take_then_advance(size)?.to_vec()) })
669                        }
670                        _ => Err(DecodeErr::WrongSimpleListTarsTypeErr),
671                    }
672                }
673                _ => Err(DecodeErr::MisMatchTarsTypeErr),
674            },
675            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
676        }
677    }
678}
679
680impl TarsDecodeListTrait<bool> for TarsDecoder {
681    fn read_list(
682        &mut self,
683        tag: u8,
684        is_require: bool,
685        default_value: Vec<bool>,
686    ) -> Result<Vec<bool>, DecodeErr> {
687        match self.skip_to_tag(tag) {
688            Ok(head) => match head.tars_type {
689                EnSimplelist => {
690                    let head = self.take_head()?;
691                    match head.tars_type {
692                        EnInt8 | EnInt16 | EnInt32 => {
693                            let size = self.read_int32(0, true, 0)? as usize;
694                            Ok(unsafe { mem::transmute(self.take_then_advance(size)?.to_vec()) })
695                        }
696                        _ => Err(DecodeErr::WrongSimpleListTarsTypeErr),
697                    }
698                }
699                _ => Err(DecodeErr::MisMatchTarsTypeErr),
700            },
701            Err(e) => TarsDecoder::return_error_if_required_not_found(e, is_require, default_value),
702        }
703    }
704}
705
706pub trait DecodeTars {
707    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr>
708    where
709        Self: Sized;
710}
711
712impl DecodeTars for i8 {
713    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
714        decoder.read_int8(tag, true, i8::default())
715    }
716}
717
718impl DecodeTars for bool {
719    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
720        decoder.read_boolean(tag, true, bool::default())
721    }
722}
723
724impl DecodeTars for i16 {
725    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
726        decoder.read_int16(tag, true, i16::default())
727    }
728}
729
730impl DecodeTars for i32 {
731    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
732        decoder.read_int32(tag, true, i32::default())
733    }
734}
735
736impl DecodeTars for i64 {
737    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
738        decoder.read_int64(tag, true, i64::default())
739    }
740}
741
742impl DecodeTars for u8 {
743    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
744        decoder.read_uint8(tag, true, u8::default())
745    }
746}
747
748impl DecodeTars for u16 {
749    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
750        decoder.read_uint16(tag, true, u16::default())
751    }
752}
753
754impl DecodeTars for u32 {
755    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
756        decoder.read_uint32(tag, true, u32::default())
757    }
758}
759
760impl DecodeTars for f32 {
761    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
762        decoder.read_float(tag, true, f32::default())
763    }
764}
765
766impl DecodeTars for f64 {
767    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
768        decoder.read_double(tag, true, f64::default())
769    }
770}
771
772impl DecodeTars for String {
773    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
774        decoder.read_string(tag, true, String::default())
775    }
776}
777
778impl<K, V> DecodeTars for BTreeMap<K, V>
779where
780    K: DecodeTars + Ord,
781    V: DecodeTars,
782{
783    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
784        decoder.read_map(tag, true, BTreeMap::<K, V>::new())
785    }
786}
787
788impl<T> DecodeTars for Vec<T>
789where
790    T: DecodeTars,
791{
792    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
793        decoder.read_list(tag, true, vec![])
794    }
795}
796
797impl DecodeTars for Bytes {
798    fn _decode(decoder: &mut TarsDecoder, tag: u8) -> Result<Self, DecodeErr> {
799        decoder.read_bytes(tag, true, Bytes::default())
800    }
801}
802
803#[cfg(test)]
804mod tests {
805    use super::*;
806    use bytes::Bytes;
807    use errors::DecodeErr;
808    use std::collections::BTreeMap;
809    use std::mem;
810
811    #[test]
812    fn test_decode_simple_list() {
813        let head: [u8; 4] = unsafe { mem::transmute(4u32.to_be()) };
814        let b: [u8; 11] = [
815            0x7d, 0x00, 0x02, head[0], head[1], head[2], head[3], 4, 5, 6, 7,
816        ];
817        let mut de = TarsDecoder::from(&b[..]);
818        let list: Vec<i8> = de.read_list(7, true, vec![]).unwrap();
819        let result: Vec<i8> = vec![4, 5, 6, 7];
820        assert_eq!(list, result);
821
822        let b2: [u8; 11] = [
823            0xed, 0x00, 0x02, head[0], head[1], head[2], head[3], 1, 0, 1, 0,
824        ];
825        let mut de2 = TarsDecoder::from(&b2[..]);
826        let list: Vec<bool> = de2.read_list(14, true, vec![]).unwrap();
827        let result: Vec<bool> = vec![true, false, true, false];
828        assert_eq!(list, result);
829
830        let olist: Vec<bool> = de2.read_list(16, false, vec![]).unwrap();
831        assert_eq!(olist, vec![]);
832
833        let olist2: Vec<i8> = de2.read_list(244, false, vec![1, 2]).unwrap();
834        assert_eq!(olist2, vec![1, 2]);
835
836        let err: Result<Vec<bool>, DecodeErr> = de.read_list(129, true, vec![true]);
837        assert_eq!(err, Err(DecodeErr::TarsTagNotFoundErr));
838    }
839
840    #[test]
841    fn test_decode_zero() {
842        let mut de = TarsDecoder::from(&b"\x0c\x1c\x2c\x3c\x4c\x5c\xfc\xff\x9c\xac\xec"[..]);
843        let o0 = de.read_int8(128, false, 0).unwrap();
844        let o1 = de.read_int8(128, false, 13).unwrap();
845
846        let v0: u8 = de.read_uint8(0, true, 0).unwrap();
847        let v1: u16 = de.read_uint16(1, true, 0).unwrap();
848        let v2: u32 = de.read_uint32(2, true, 0).unwrap();
849        let v3: i8 = de.read_int8(3, true, 0).unwrap();
850        let v4: i16 = de.read_int16(4, true, 0).unwrap();
851        let v5: i32 = de.read_int32(5, true, 0).unwrap();
852        let v6: i64 = de.read_int64(255, true, 0).unwrap();
853        let v7: f32 = de.read_float(9, true, 0.0).unwrap();
854        let v8: f64 = de.read_double(10, true, 0.0).unwrap();
855        let v9: bool = de.read_boolean(14, true, false).unwrap();
856
857        assert_eq!(o0, 0);
858        assert_eq!(o1, 13);
859
860        assert_eq!(v0, 0);
861        assert_eq!(v1, 0);
862        assert_eq!(v2, 0);
863        assert_eq!(v3, 0);
864        assert_eq!(v4, 0);
865        assert_eq!(v5, 0);
866        assert_eq!(v6, 0);
867        assert_eq!(v7, 0.0);
868        assert_eq!(v8, 0.0);
869        assert_eq!(v9, false);
870
871        let err: Result<u32, DecodeErr> = de.read_uint32(129, true, 0);
872        assert_eq!(err, Err(DecodeErr::TarsTagNotFoundErr));
873    }
874
875    #[test]
876    fn test_decode_list() {
877        let size: [u8; 4] = unsafe { mem::transmute(2u32.to_be()) };
878        let b: [u8; 28] = [
879            0xa9,
880            0x02,
881            size[0],
882            size[1],
883            size[2],
884            size[3],
885            // {tag: 0, type: 6}
886            0x06,
887            7,
888            b'f',
889            b'o',
890            b'o',
891            b' ',
892            b'b',
893            b'a',
894            b'r',
895            // {tag: 0, type: 6}
896            0x06,
897            11,
898            b'h',
899            b'e',
900            b'l',
901            b'l',
902            b'o',
903            b' ',
904            b'w',
905            b'o',
906            b'r',
907            b'l',
908            b'd',
909        ];
910        let mut de = TarsDecoder::from(&b[..]);
911        let list: Vec<String> = de.read_list(10, true, vec![]).unwrap();
912        assert_eq!(list[0], String::from(&"foo bar"[..]));
913        assert_eq!(list[1], String::from(&"hello world"[..]));
914
915        assert_eq!(
916            de.read_list(10, true, vec![]) as Result<Vec<String>, DecodeErr>,
917            Err(DecodeErr::TarsTagNotFoundErr)
918        );
919
920        let b2: [u8; 6] = [0x99, 0x02, 0, 0, 0, 0];
921        let mut de2 = TarsDecoder::from(&b2[..]);
922        let v2: Vec<BTreeMap<String, i32>> = de2.read_list(9, true, vec![]).unwrap();
923        assert_eq!(v2, vec![]);
924
925        let v3: Vec<BTreeMap<String, i32>> = de2.read_list(128, false, vec![]).unwrap();
926        assert_eq!(v3, vec![]);
927
928        let err: Result<Vec<BTreeMap<String, i32>>, DecodeErr> = de2.read_list(129, true, vec![]);
929        assert_eq!(err, Err(DecodeErr::TarsTagNotFoundErr));
930    }
931
932    #[test]
933    fn test_decode_map() {
934        let size: [u8; 4] = unsafe { mem::transmute(1u32.to_be()) };
935        let b: [u8; 28] = [
936            0x48,
937            0x02,
938            size[0],
939            size[1],
940            size[2],
941            size[3],
942            // {tag: 0, type: 6}
943            0x06,
944            7,
945            b'f',
946            b'o',
947            b'o',
948            b' ',
949            b'b',
950            b'a',
951            b'r',
952            // {tag: 1, type: 6}
953            0x16,
954            11,
955            b'h',
956            b'e',
957            b'l',
958            b'l',
959            b'o',
960            b' ',
961            b'w',
962            b'o',
963            b'r',
964            b'l',
965            b'd',
966        ];
967        let mut de = TarsDecoder::from(&b[..]);
968        let map: BTreeMap<String, String> = de.read_map(4, true, BTreeMap::new()).unwrap();
969        let value2 = map.get(&String::from(&"foo bar"[..])).unwrap();
970        assert_eq!(value2, &String::from(&"hello world"[..]));
971
972        let b2: [u8; 6] = [0x48, 0x02, 0, 0, 0, 0];
973        let mut de2 = TarsDecoder::from(&b2[..]);
974        let map2: BTreeMap<Vec<String>, BTreeMap<i32, String>> =
975            de2.read_map(4, true, BTreeMap::new()).unwrap();
976        assert_eq!(map2, BTreeMap::new());
977
978        let omap2: BTreeMap<Vec<String>, BTreeMap<i32, String>> =
979            de2.read_map(129, false, BTreeMap::new()).unwrap();
980        assert_eq!(omap2, BTreeMap::new());
981
982        let err: Result<BTreeMap<Vec<String>, BTreeMap<i32, String>>, DecodeErr> =
983            de2.read_map(129, true, BTreeMap::new());
984        assert_eq!(err, Err(DecodeErr::TarsTagNotFoundErr));
985    }
986
987    #[test]
988    fn test_decode_int64() {
989        let b: [u8; 8] = unsafe { mem::transmute(0x0acb8b9d9d9d9d9di64.to_be()) };
990        let mut header_vec: Vec<u8> = vec![0xf3, 0xff];
991        header_vec.extend_from_slice(&b);
992        let mut de2 = TarsDecoder::from(header_vec.as_slice());
993        let i: i64 = de2.read_int64(255, true, 0).unwrap();
994        assert_eq!(i, 0x0acb8b9d9d9d9d9d);
995
996        let i2: i64 = de2.read_int64(244, false, i64::max_value()).unwrap();
997        assert_eq!(i2, i64::max_value());
998
999        let err: Result<i64, DecodeErr> = de2.read_int64(129, true, 0);
1000        assert_eq!(err, Err(DecodeErr::TarsTagNotFoundErr));
1001    }
1002
1003    #[test]
1004    fn test_decode_int32() {
1005        let b: [u8; 4] = unsafe { mem::transmute(0x0acb8b9di32.to_be()) };
1006        let mut header_vec: Vec<u8> = vec![0xf2, 0xff];
1007        header_vec.extend_from_slice(&b);
1008        let mut de2 = TarsDecoder::from(header_vec.as_slice());
1009        let i: i32 = de2.read_int32(255, true, 0).unwrap();
1010        assert_eq!(i, 0x0acb8b9di32);
1011
1012        let i2: i32 = de2.read_int32(244, false, i32::max_value()).unwrap();
1013        assert_eq!(i2, i32::max_value());
1014
1015        let err: Result<i32, DecodeErr> = de2.read_int32(129, true, 0);
1016        assert_eq!(err, Err(DecodeErr::TarsTagNotFoundErr));
1017    }
1018
1019    #[test]
1020    fn test_decode_int16() {
1021        let b: [u8; 2] = unsafe { mem::transmute(0x0acbi16.to_be()) };
1022        let mut header_vec: Vec<u8> = vec![0xe1];
1023        header_vec.extend_from_slice(&b);
1024        let mut de2 = TarsDecoder::from(header_vec.as_slice());
1025        let i: i16 = de2.read_int16(14, true, 0).unwrap();
1026        assert_eq!(i, 0x0acbi16);
1027
1028        let i2: i16 = de2.read_int16(244, false, i16::max_value()).unwrap();
1029        assert_eq!(i2, i16::max_value());
1030
1031        let err: Result<i16, DecodeErr> = de2.read_int16(129, true, 0);
1032        assert_eq!(err, Err(DecodeErr::TarsTagNotFoundErr));
1033    }
1034
1035    #[test]
1036    fn test_decode_int8() {
1037        let header_vec: Vec<u8> = vec![0xe0, 0xff];
1038        let mut de2 = TarsDecoder::from(header_vec.as_slice());
1039        let i: i8 = de2.read_int8(14, true, 0).unwrap();
1040        assert_eq!(i, -1);
1041
1042        let mut de2 = TarsDecoder::from(header_vec.as_slice());
1043        let i = de2.read_int8(15, false, 0).unwrap();
1044        let i2 = de2.read_int8(14, false, 0).unwrap();
1045        assert_eq!(i, 0);
1046        assert_eq!(i2, -1);
1047    }
1048
1049    // #[test]
1050    // fn test_decode_double() {
1051    //     let b2: [u8; 8] = unsafe { mem::transmute(0.633313f64.to_bits().to_be()) };
1052    //     let mut de2 = TarsDecoder::from(&b2[..]);
1053    //     let f: f64 = de2.read(TarsTypeMark::EnDouble.value()).unwrap();
1054    //     assert!(f == 0.633313f64);
1055    // }
1056
1057    // #[test]
1058    // fn test_decode_float() {
1059    //     let b2: [u8; 4] = unsafe { mem::transmute(0.35524f32.to_bits().to_be()) };
1060    //     let mut de2 = TarsDecoder::from(&b2[..]);
1061    //     let f: f32 = de2.read(TarsTypeMark::EnFloat.value()).unwrap();
1062    //     assert!(f == 0.35524f32);
1063    // }
1064
1065    #[test]
1066    fn test_decode_string() {
1067        // test read string1
1068        let d: [u8; 9] = [0x06, 0x07, b'f', b'o', b'o', b' ', b'b', b'a', b'r'];
1069        let mut de = TarsDecoder::from(&d[..]);
1070        assert_eq!(
1071            de.read_string(0, true, String::default()).unwrap(),
1072            String::from(&"foo bar"[..])
1073        );
1074
1075        // test read string4
1076        let size: [u8; 4] = unsafe { mem::transmute(7u32.to_be()) };
1077        let d2: [u8; 12] = [
1078            0x27, size[0], size[1], size[2], size[3], b'f', b'o', b'o', b' ', b'b', b'a', b'r',
1079        ];
1080        let mut de2 = TarsDecoder::from(&d2[..]);
1081        assert_eq!(
1082            de2.read_string(2, true, String::default()).unwrap(),
1083            String::from(&"foo bar"[..])
1084        );
1085
1086        let i2: String = de2.read_string(244, false, String::default()).unwrap();
1087        assert_eq!(i2, String::default());
1088
1089        let err: Result<String, DecodeErr> = de2.read_string(129, true, String::default());
1090        assert_eq!(err, Err(DecodeErr::TarsTagNotFoundErr));
1091    }
1092
1093    #[test]
1094    fn test_decode_bool() {
1095        let d: [u8; 3] = [0x0c, 0x10, 0x01];
1096        let mut de = TarsDecoder::from(&d[..]);
1097        let b: bool = de.read_boolean(0, true, false).unwrap();
1098        let ob: bool = de.read_boolean(2, false, false).unwrap();
1099
1100        let b2: bool = de.read_boolean(1, true, false).unwrap();
1101
1102        let ob2: bool = de.read_boolean(3, false, true).unwrap();
1103
1104        assert_eq!(b, false);
1105        assert_eq!(b2, true);
1106        assert_eq!(ob, false);
1107        assert_eq!(ob2, true);
1108    }
1109
1110    #[test]
1111    fn test_decode_bytes() {
1112        let d: [u8; 19] = *b"\x9d\x00\x02\x00\x00\x00\x0chello world!";
1113        let mut de = TarsDecoder::from(&d[..]);
1114        let b: Bytes = de.read_bytes(9, true, Bytes::default()).unwrap();
1115        assert_eq!(b, Bytes::from(&b"hello world!"[..]));
1116
1117        let i2: Bytes = de.read_bytes(244, false, Bytes::default()).unwrap();
1118        assert_eq!(i2, Bytes::default());
1119
1120        let err: Result<Bytes, DecodeErr> = de.read_bytes(129, true, Bytes::default());
1121        assert_eq!(err, Err(DecodeErr::TarsTagNotFoundErr));
1122    }
1123
1124    // #[test]
1125    // fn test_decode_struct() {
1126    //     struct Test {
1127    //         a: u32
1128    //         b: Vec<i8>
1129    //     }
1130    // }
1131}
tars_stream/tars_decoder.rs

tars_stream/
tars_decoder.rs
