Smaller write len

Author: kornelski

rmp/src/encode/bin.rs

@@ -13,19 +13,22 @@ use crate::Marker;
 /// This function will return `ValueWriteError` on any I/O error occurred while writing either the
 /// marker or the data.
 pub fn write_bin_len<W: RmpWrite>(wr: &mut W, len: u32) -> Result<Marker, ValueWriteError<W::Error>> {
-    if len < 256 {
-        write_marker(&mut *wr, Marker::Bin8)?;
-        wr.write_data_u8(len as u8)?;
-        Ok(Marker::Bin8)
+    let marker = if len < 256 {
+        Marker::Bin8
     } else if len <= u16::MAX as u32 {
-        write_marker(&mut *wr, Marker::Bin16)?;
-        wr.write_data_u16(len as u16)?;
-        Ok(Marker::Bin16)
+        Marker::Bin16
     } else {
-        write_marker(&mut *wr, Marker::Bin32)?;
+        Marker::Bin32
+    };
+    write_marker(&mut *wr, marker)?;
+    if marker == Marker::Bin8 {
+        wr.write_data_u8(len as u8)?;
+    } else if marker == Marker::Bin16 {
+        wr.write_data_u16(len as u16)?;
+    } else if marker == Marker::Bin32 {
         wr.write_data_u32(len)?;
-        Ok(Marker::Bin32)
     }
+    Ok(marker)
 }
 
 /// Encodes and attempts to write the most efficient binary implementation to the given `Write`.

rmp/src/encode/mod.rs

@@ -257,18 +257,19 @@ impl<E: RmpWriteErr> Display for ValueWriteError<E> {
 /// marker or the data.
 pub fn write_array_len<W: RmpWrite>(wr: &mut W, len: u32) -> Result<Marker, ValueWriteError<W::Error>> {
     let marker = if len < 16 {
-        write_marker(wr, Marker::FixArray(len as u8))?;
         Marker::FixArray(len as u8)
     } else if len <= u16::MAX as u32 {
-        write_marker(wr, Marker::Array16)?;
-        wr.write_data_u16(len as u16)?;
         Marker::Array16
     } else {
-        write_marker(wr, Marker::Array32)?;
-        wr.write_data_u32(len)?;
         Marker::Array32
     };
 
+    write_marker(wr, marker)?;
+    if marker == Marker::Array16 {
+        wr.write_data_u16(len as u16)?;
+    } else if marker == Marker::Array32 {
+        wr.write_data_u32(len)?;
+    }
     Ok(marker)
 }
 
@@ -281,18 +282,19 @@ pub fn write_array_len<W: RmpWrite>(wr: &mut W, len: u32) -> Result<Marker, Valu
 /// marker or the data.
 pub fn write_map_len<W: RmpWrite>(wr: &mut W, len: u32) -> Result<Marker, ValueWriteError<W::Error>> {
     let marker = if len < 16 {
-        write_marker(wr, Marker::FixMap(len as u8))?;
         Marker::FixMap(len as u8)
     } else if len <= u16::MAX as u32 {
-        write_marker(wr, Marker::Map16)?;
-        wr.write_data_u16(len as u16)?;
         Marker::Map16
     } else {
-        write_marker(wr, Marker::Map32)?;
-        wr.write_data_u32(len)?;
         Marker::Map32
     };
 
+    write_marker(wr, marker)?;
+    if marker == Marker::Map16 {
+        wr.write_data_u16(len as u16)?;
+    } else if marker == Marker::Map32 {
+        wr.write_data_u32(len)?;
+    }
     Ok(marker)
 }
 
@@ -310,42 +312,24 @@ pub fn write_map_len<W: RmpWrite>(wr: &mut W, len: u32) -> Result<Marker, ValueW
 /// 2-byte type information.
 pub fn write_ext_meta<W: RmpWrite>(wr: &mut W, len: u32, ty: i8) -> Result<Marker, ValueWriteError<W::Error>> {
     let marker = match len {
-        1 => {
-            write_marker(wr, Marker::FixExt1)?;
-            Marker::FixExt1
-        }
-        2 => {
-            write_marker(wr, Marker::FixExt2)?;
-            Marker::FixExt2
-        }
-        4 => {
-            write_marker(wr, Marker::FixExt4)?;
-            Marker::FixExt4
-        }
-        8 => {
-            write_marker(wr, Marker::FixExt8)?;
-            Marker::FixExt8
-        }
-        16 => {
-            write_marker(wr, Marker::FixExt16)?;
-            Marker::FixExt16
-        }
-        len if len < 256 => {
-            write_marker(wr, Marker::Ext8)?;
-            wr.write_data_u8(len as u8)?;
-            Marker::Ext8
-        }
-        len if len < 65536 => {
-            write_marker(wr, Marker::Ext16)?;
-            wr.write_data_u16(len as u16)?;
-            Marker::Ext16
-        }
-        len => {
-            write_marker(wr, Marker::Ext32)?;
-            wr.write_data_u32(len)?;
-            Marker::Ext32
-        }
+        1 => Marker::FixExt1,
+        2 => Marker::FixExt2,
+        4 => Marker::FixExt4,
+        8 => Marker::FixExt8,
+        16 => Marker::FixExt16,
+        0..=255 => Marker::Ext8,
+        256..=65535 => Marker::Ext16,
+        _ => Marker::Ext32,
     };
+    write_marker(wr, marker)?;
+
+    if marker == Marker::Ext8 {
+        wr.write_data_u8(len as u8)?;
+    } else if marker == Marker::Ext16 {
+        wr.write_data_u16(len as u16)?;
+    } else if marker == Marker::Ext32 {
+        wr.write_data_u32(len)?;
+    }
 
     wr.write_data_i8(ty)?;
 

rmp/src/encode/str.rs

@@ -10,22 +10,27 @@ use crate::Marker;
 /// This function will return `ValueWriteError` on any I/O error occurred while writing either the
 /// marker or the data.
 pub fn write_str_len<W: RmpWrite>(wr: &mut W, len: u32) -> Result<Marker, ValueWriteError<W::Error>> {
-    if len < 32 {
-        write_marker(wr, Marker::FixStr(len as u8))?;
-        Ok(Marker::FixStr(len as u8))
+    let marker = if len < 32 {
+        Marker::FixStr(len as u8)
     } else if len < 256 {
-        write_marker(wr, Marker::Str8)?;
-        wr.write_data_u8(len as u8)?;
-        Ok(Marker::Str8)
+        Marker::Str8
     } else if len <= u16::MAX as u32 {
-        write_marker(wr, Marker::Str16)?;
-        wr.write_data_u16(len as u16)?;
-        Ok(Marker::Str16)
+        Marker::Str16
     } else {
-        write_marker(wr, Marker::Str32)?;
+        Marker::Str32
+    };
+
+    write_marker(wr, marker)?;
+    if marker == Marker::Str8 {
+        wr.write_data_u8(len as u8)?;
+    }
+    if marker == Marker::Str16 {
+        wr.write_data_u16(len as u16)?;
+    }
+    if marker == Marker::Str32 {
         wr.write_data_u32(len)?;
-        Ok(Marker::Str32)
     }
+    Ok(marker)
 }
 
 /// Encodes and attempts to write the most efficient string binary representation to the