Skip to content

Commit 6d256d4

Browse files
kornelskikornelski
committed
Reduce generics bloat
1 parent da49802 commit 6d256d4

File tree

1 file changed

+108
-31
lines changed

1 file changed

+108
-31
lines changed

Diff for: ‎rmp-serde/src/decode.rs

+108-31
Original file line numberDiff line numberDiff line change
@@ -493,7 +493,10 @@ impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::Deserializer<'de>
493493
Reference::Copied(bytes) => visitor.visit_bytes(bytes),
494494
}
495495
}
496-
ExtDeserializerState::ReadBinary => unreachable!(),
496+
ExtDeserializerState::ReadBinary => {
497+
debug_assert!(false);
498+
Err(Error::TypeMismatch(Marker::Reserved))
499+
},
497500
}
498501
}
499502

@@ -504,35 +507,54 @@ impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::Deserializer<'de>
504507
}
505508
}
506509

507-
impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
508-
#[inline(never)]
509-
fn deserialize_any_inner<V: Visitor<'de>>(&mut self, visitor: V, allow_bytes: bool) -> Result<V::Value, Error> {
510+
#[inline(never)]
511+
fn any_num<'de, R: ReadSlice<'de>, V: Visitor<'de>>(rd: &mut R, visitor: V, marker: Marker) -> Result<V::Value, Error> {
512+
match marker {
513+
Marker::Null => visitor.visit_unit(),
514+
Marker::True |
515+
Marker::False => visitor.visit_bool(marker == Marker::True),
516+
Marker::FixPos(val) => visitor.visit_u8(val),
517+
Marker::FixNeg(val) => visitor.visit_i8(val),
518+
Marker::U8 => visitor.visit_u8(rd.read_data_u8()?),
519+
Marker::U16 => visitor.visit_u16(rd.read_data_u16()?),
520+
Marker::U32 => visitor.visit_u32(rd.read_data_u32()?),
521+
Marker::U64 => visitor.visit_u64(rd.read_data_u64()?),
522+
Marker::I8 => visitor.visit_i8(rd.read_data_i8()?),
523+
Marker::I16 => visitor.visit_i16(rd.read_data_i16()?),
524+
Marker::I32 => visitor.visit_i32(rd.read_data_i32()?),
525+
Marker::I64 => visitor.visit_i64(rd.read_data_i64()?),
526+
Marker::F32 => visitor.visit_f32(rd.read_data_f32()?),
527+
Marker::F64 => visitor.visit_f64(rd.read_data_f64()?),
528+
other_marker => Err(Error::TypeMismatch(other_marker)),
529+
}
530+
}
510531

532+
impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
533+
fn any_inner<V: Visitor<'de>>(&mut self, visitor: V, allow_bytes: bool) -> Result<V::Value, Error> {
511534
let marker = self.take_or_read_marker()?;
512-
513535
match marker {
514-
Marker::Null => visitor.visit_unit(),
536+
Marker::Null |
515537
Marker::True |
516-
Marker::False => visitor.visit_bool(marker == Marker::True),
517-
Marker::FixPos(val) => visitor.visit_u8(val),
518-
Marker::FixNeg(val) => visitor.visit_i8(val),
519-
Marker::U8 => visitor.visit_u8(self.rd.read_data_u8()?),
520-
Marker::U16 => visitor.visit_u16(self.rd.read_data_u16()?),
521-
Marker::U32 => visitor.visit_u32(self.rd.read_data_u32()?),
522-
Marker::U64 => visitor.visit_u64(self.rd.read_data_u64()?),
523-
Marker::I8 => visitor.visit_i8(self.rd.read_data_i8()?),
524-
Marker::I16 => visitor.visit_i16(self.rd.read_data_i16()?),
525-
Marker::I32 => visitor.visit_i32(self.rd.read_data_i32()?),
526-
Marker::I64 => visitor.visit_i64(self.rd.read_data_i64()?),
527-
Marker::F32 => visitor.visit_f32(self.rd.read_data_f32()?),
528-
Marker::F64 => visitor.visit_f64(self.rd.read_data_f64()?),
538+
Marker::False |
539+
Marker::FixPos(_) |
540+
Marker::FixNeg(_) |
541+
Marker::U8 |
542+
Marker::U16 |
543+
Marker::U32 |
544+
Marker::U64 |
545+
Marker::I8 |
546+
Marker::I16 |
547+
Marker::I32 |
548+
Marker::I64 |
549+
Marker::F32 |
550+
Marker::F64 => any_num(&mut self.rd, visitor, marker),
529551
Marker::FixStr(_) | Marker::Str8 | Marker::Str16 | Marker::Str32 => {
530552
let len = match marker {
531553
Marker::FixStr(len) => Ok(len.into()),
532554
Marker::Str8 => read_u8(&mut self.rd).map(u32::from),
533555
Marker::Str16 => read_u16(&mut self.rd).map(u32::from),
534556
Marker::Str32 => read_u32(&mut self.rd).map(u32::from),
535-
_ => unreachable!(),
557+
_ => return Err(Error::TypeMismatch(Marker::Reserved)),
536558
}?;
537559
read_str_data(&mut self.rd, len, visitor)
538560
}
@@ -543,7 +565,7 @@ impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
543565
Marker::FixArray(len) => len.into(),
544566
Marker::Array16 => read_u16(&mut self.rd)?.into(),
545567
Marker::Array32 => read_u32(&mut self.rd)?,
546-
_ => unreachable!(),
568+
_ => return Err(Error::TypeMismatch(Marker::Reserved)),
547569
};
548570

549571
depth_count!(self.depth, {
@@ -562,7 +584,7 @@ impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
562584
Marker::FixMap(len) => len.into(),
563585
Marker::Map16 => read_u16(&mut self.rd)?.into(),
564586
Marker::Map32 => read_u32(&mut self.rd)?,
565-
_ => unreachable!(),
587+
_ => return Err(Error::TypeMismatch(Marker::Reserved)),
566588
};
567589

568590
depth_count!(self.depth, {
@@ -579,7 +601,7 @@ impl<'de, R: ReadSlice<'de>, C: SerializerConfig> Deserializer<R, C> {
579601
Marker::Bin8 => read_u8(&mut self.rd).map(u32::from),
580602
Marker::Bin16 => read_u16(&mut self.rd).map(u32::from),
581603
Marker::Bin32 => read_u32(&mut self.rd).map(u32::from),
582-
_ => unreachable!(),
604+
_ => return Err(Error::TypeMismatch(Marker::Reserved)),
583605
}?;
584606
match read_bin_data(&mut self.rd, len)? {
585607
Reference::Borrowed(buf) if allow_bytes => visitor.visit_borrowed_bytes(buf),
@@ -617,7 +639,7 @@ impl<'de, 'a, R: ReadSlice<'de>, C: SerializerConfig> serde::Deserializer<'de> f
617639
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
618640
where V: Visitor<'de>
619641
{
620-
self.deserialize_any_inner(visitor, true)
642+
self.any_inner(visitor, true)
621643
}
622644

623645
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -714,30 +736,84 @@ impl<'de, 'a, R: ReadSlice<'de>, C: SerializerConfig> serde::Deserializer<'de> f
714736

715737
#[inline]
716738
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
717-
self.deserialize_any_inner(visitor, false)
739+
self.any_inner(visitor, false)
718740
}
719741

720742
#[inline]
721743
fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
722-
self.deserialize_any_inner(visitor, false)
744+
self.any_inner(visitor, false)
723745
}
724746

725747
#[inline]
726748
fn deserialize_struct<V>(self, _: &'static str, _: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
727-
self.deserialize_any_inner(visitor, false)
749+
self.any_inner(visitor, false)
728750
}
729751

730752
#[inline]
731753
fn deserialize_tuple_struct<V>(self, _: &'static str, _: usize, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
732-
self.deserialize_any_inner(visitor, false)
754+
self.any_inner(visitor, false)
733755
}
734756

735757
forward_to_deserialize_any! {
736-
bool u8 u16 u32 u64 i8 i16 i32 i64 f32
737-
f64 char str string bytes byte_buf unit
738-
map identifier
758+
bytes byte_buf unit
759+
map identifier str string char
739760
ignored_any
740761
}
762+
763+
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
764+
let marker = self.take_or_read_marker()?;
765+
any_num(&mut self.rd, visitor, marker)
766+
}
767+
768+
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
769+
let marker = self.take_or_read_marker()?;
770+
any_num(&mut self.rd, visitor, marker)
771+
}
772+
773+
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
774+
let marker = self.take_or_read_marker()?;
775+
any_num(&mut self.rd, visitor, marker)
776+
}
777+
778+
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
779+
let marker = self.take_or_read_marker()?;
780+
any_num(&mut self.rd, visitor, marker)
781+
}
782+
783+
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
784+
let marker = self.take_or_read_marker()?;
785+
any_num(&mut self.rd, visitor, marker)
786+
}
787+
788+
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
789+
let marker = self.take_or_read_marker()?;
790+
any_num(&mut self.rd, visitor, marker)
791+
}
792+
793+
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
794+
let marker = self.take_or_read_marker()?;
795+
any_num(&mut self.rd, visitor, marker)
796+
}
797+
798+
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
799+
let marker = self.take_or_read_marker()?;
800+
any_num(&mut self.rd, visitor, marker)
801+
}
802+
803+
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
804+
let marker = self.take_or_read_marker()?;
805+
any_num(&mut self.rd, visitor, marker)
806+
}
807+
808+
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
809+
let marker = self.take_or_read_marker()?;
810+
any_num(&mut self.rd, visitor, marker)
811+
}
812+
813+
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de> {
814+
let marker = self.take_or_read_marker()?;
815+
any_num(&mut self.rd, visitor, marker)
816+
}
741817
}
742818

743819
struct SeqAccess<'a, R, C> {
@@ -779,6 +855,7 @@ struct MapAccess<'a, R, C> {
779855
}
780856

781857
impl<'a, R: 'a, C> MapAccess<'a, R, C> {
858+
#[inline]
782859
fn new(de: &'a mut Deserializer<R, C>, len: u32) -> Self {
783860
MapAccess { de, left: len }
784861
}

0 commit comments

Comments
 (0)