bencode inspired tight self describing serialization format
Diffstat (limited to 'src/ser.rs')
| -rw-r--r-- | src/ser.rs | 49 |
1 files changed, 22 insertions, 27 deletions
@@ -1,6 +1,6 @@ use crate::error::{Error, Result}; use crate::serde::T; -use raad::le::*; +use raad::le::W; use serde::{Serialize, ser}; use std::io::Write; @@ -39,23 +39,21 @@ impl<W: std::io::Write> Serializer<W> { if w == 0 { self.w.w(n)?; break; - } else { - self.w.w(n | 1 << 7)?; } + self.w.w(n | 1 << 7)?; } Ok(()) } - fn sleb128(&mut self, mut value: i128) -> Result<()> { + fn sleb128(&mut self, mut w: i128) -> Result<()> { loop { - let n = (value & 127) as u8; - value >>= 7; - let sign_bit = (n & 64) != 0; - if (value == 0 && !sign_bit) || (value == -1 && sign_bit) { + let n = (w & 127) as i8; + w >>= 7; + let sign = (n & 64) != 0; + if (w == 0 && !sign) || (w == -1 && sign) { self.w.w(n)?; break; - } else { - self.w.w(n | 1 << 7)?; } + self.w.w(n | 1 << 7)?; } Ok(()) } @@ -90,7 +88,7 @@ impl<W: std::io::Write> ser::Serializer for &mut Serializer<W> { // into the output string. fn serialize_bool(self, v: bool) -> Result<()> { // println!("serialize bool {v}"); - self.w.w(v as u8)?; + self.w.w(u8::from(v))?; Ok(()) } @@ -113,7 +111,7 @@ impl<W: std::io::Write> ser::Serializer for &mut Serializer<W> { fn serialize_i64(self, v: i64) -> Result<()> { // println!("serialize i64 {v}"); self.t(T::Int)?; - self.sleb128(v as i128) + self.sleb128(v.into()) } fn serialize_u8(self, v: u8) -> Result<()> { @@ -254,25 +252,22 @@ impl<W: std::io::Write> ser::Serializer for &mut Serializer<W> { fn serialize_tuple_variant( self, _name: &'static str, - _variant_index: u32, + idx: u32, _variant: &'static str, - _len: usize, + len: usize, ) -> Result<Self::SerializeTupleVariant> { - // println!("serialize tuple variant {_variant} of {_name} {_variant_index} {_variant}"); + // println!("serialize tuple variant {_variant} of {_name} {idx} {_variant}"); self.w.w(T::TVariant as u8)?; - self.serialize_u32(_variant_index)?; - self.leb128(_len as u128)?; - // self.output += "{"; - // variant.serialize(&mut *self)?; - // self.output += ":["; + self.serialize_u32(idx)?; + self.leb128(len as u128)?; Ok(self) } // Maps are represented in JSON as `{ K: V, K: V, ... }`. - fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> { + fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> { self.w.w(T::Map as u8)?; // println!("{_len:?}"); - self.leb128(_len.ok_or(Error::LenLess)? as u128)?; + self.leb128(len.ok_or(Error::LenLess)? as u128)?; Ok(self) // Ok(self) @@ -292,14 +287,14 @@ impl<W: std::io::Write> ser::Serializer for &mut Serializer<W> { fn serialize_struct_variant( self, _name: &'static str, - _variant_index: u32, - variant: &'static str, - _len: usize, + idx: u32, + _variant: &'static str, + len: usize, ) -> Result<Self::SerializeStructVariant> { // println!("ser struct v {_name} {_variant_index} {variant} {_len}"); self.w.w(T::SVariant as u8)?; - self.serialize_u32(_variant_index)?; - self.leb128(_len as u128)?; + self.serialize_u32(idx)?; + self.leb128(len as u128)?; Ok(self) } } |