258 lines
8.5 KiB
Rust
258 lines
8.5 KiB
Rust
use serde::de::{
|
|
self, DeserializeSeed, MapAccess, SeqAccess,
|
|
Visitor,
|
|
};
|
|
use serde::{Serialize};
|
|
use serde::Deserialize;
|
|
|
|
use crate::bipack_source::{BipackSource, VecSource};
|
|
use crate::error::{Error, Result};
|
|
use crate::ser::to_bytes;
|
|
use crate::tools::to_dump;
|
|
|
|
pub struct Deserializer {
|
|
// This string starts with the input data and characters are truncated off
|
|
// the beginning as data is parsed.
|
|
input: VecSource,
|
|
}
|
|
|
|
pub fn from_bytes<'de,T: Deserialize<'de>>(source: Vec<u8>) -> Result<T> {
|
|
let mut des = Deserializer { input: VecSource::from(source)};
|
|
T::deserialize(&mut des)
|
|
}
|
|
|
|
impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer {
|
|
type Error = Error;
|
|
|
|
fn deserialize_any<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
Err(Error::NotPossible)
|
|
}
|
|
|
|
fn deserialize_bool<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_bool(if self.input.get_u8()? == 0 { false } else { true } )
|
|
}
|
|
|
|
fn deserialize_i8<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_i8(self.input.get_i8()?)
|
|
}
|
|
|
|
fn deserialize_i16<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_i16(self.input.get_signed()? as i16)
|
|
}
|
|
|
|
fn deserialize_i32<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_i32(self.input.get_signed()? as i32)
|
|
}
|
|
|
|
fn deserialize_i64<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_i64(self.input.get_signed()?)
|
|
}
|
|
|
|
fn deserialize_u8<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_u8(self.input.get_u8()?)
|
|
}
|
|
|
|
fn deserialize_u16<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_u16(self.input.get_unsigned()? as u16)
|
|
}
|
|
|
|
fn deserialize_u32<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_u32(self.input.get_unsigned()? as u32)
|
|
}
|
|
|
|
fn deserialize_u64<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_u64(self.input.get_unsigned()?)
|
|
}
|
|
|
|
fn deserialize_f32<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
Err(Error::NotImplemented)
|
|
}
|
|
|
|
fn deserialize_f64<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
Err(Error::NotImplemented)
|
|
}
|
|
|
|
fn deserialize_char<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
let ch = self.input.get_str()?;
|
|
if ch.len() != 1 {
|
|
Err(Error::BadFormat(format!("Char length is {}, should be 1 {:?}", ch.len(), ch)))
|
|
}
|
|
else {
|
|
visitor.visit_char(ch.chars().next().unwrap())
|
|
}
|
|
}
|
|
|
|
fn deserialize_str<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_string( self.input.get_str()?)
|
|
}
|
|
|
|
fn deserialize_string<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_string(self.input.get_str()?)
|
|
}
|
|
|
|
fn deserialize_bytes<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_byte_buf(self.input.get_var_bytes()?)
|
|
}
|
|
|
|
fn deserialize_byte_buf<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_byte_buf(self.input.get_var_bytes()?)
|
|
}
|
|
|
|
fn deserialize_option<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
let marker = self.input.get_u8()?;
|
|
if marker == 0 {
|
|
visitor.visit_none()
|
|
} else {
|
|
visitor.visit_some(self)
|
|
}
|
|
}
|
|
|
|
fn deserialize_unit<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_unit()
|
|
}
|
|
|
|
fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
self.deserialize_unit(visitor)
|
|
}
|
|
|
|
fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_newtype_struct(self)
|
|
}
|
|
|
|
fn deserialize_seq<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
let size = self.input.get_unsigned()? as usize;
|
|
visitor.visit_seq(SimpleSeq::new(self, size))
|
|
}
|
|
|
|
fn deserialize_tuple<V>(self, len: usize, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_seq(SimpleSeq::new(self, len))
|
|
}
|
|
|
|
fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_seq(SimpleSeq::new(self, len))
|
|
}
|
|
|
|
fn deserialize_map<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
let size = self.input.get_unsigned()?;
|
|
visitor.visit_map(SimpleMap { de: self, size: size as usize} )
|
|
}
|
|
|
|
fn deserialize_struct<V>(self, name: &'static str, fields: &'static [&'static str], visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
visitor.visit_seq(SimpleSeq::new(self, fields.len() ))
|
|
}
|
|
|
|
fn deserialize_enum<V>(self, name: &'static str, variants: &'static [&'static str], visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
todo!()
|
|
}
|
|
|
|
fn deserialize_identifier<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
Err(Error::NotPossible)
|
|
}
|
|
|
|
fn deserialize_ignored_any<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
|
|
Err(Error::NotPossible)
|
|
}
|
|
|
|
fn is_human_readable(&self) -> bool {
|
|
false
|
|
}
|
|
}
|
|
|
|
struct SimpleSeq<'a> {
|
|
de: &'a mut Deserializer,
|
|
size: usize,
|
|
}
|
|
|
|
impl<'a> SimpleSeq<'a> {
|
|
fn new(de: &'a mut Deserializer,size: usize) -> Self {
|
|
SimpleSeq {
|
|
de,
|
|
size: size,
|
|
}
|
|
}
|
|
}
|
|
|
|
// `SeqAccess` is provided to the `Visitor` to give it the ability to iterate
|
|
// through elements of the sequence.
|
|
impl<'de, 'a> SeqAccess<'de> for SimpleSeq<'a> {
|
|
type Error = Error;
|
|
|
|
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
|
|
where
|
|
T: DeserializeSeed<'de>,
|
|
{
|
|
if self.size < 1 {
|
|
return Ok(None);
|
|
}
|
|
self.size -= 1;
|
|
seed.deserialize(&mut *self.de).map(Some)
|
|
}
|
|
}
|
|
|
|
|
|
struct SimpleMap<'a> {
|
|
de: &'a mut Deserializer,
|
|
size: usize,
|
|
}
|
|
|
|
impl<'de, 'a> MapAccess<'de> for SimpleMap<'a> {
|
|
type Error = Error;
|
|
|
|
fn next_key_seed<K>(&mut self, seed: K) -> std::result::Result<Option<K::Value>, Self::Error> where K: DeserializeSeed<'de> {
|
|
if self.size < 1 {
|
|
Ok(None)
|
|
}
|
|
else {
|
|
self.size -= 1;
|
|
seed.deserialize(&mut *self.de).map(Some)
|
|
}
|
|
}
|
|
|
|
fn next_value_seed<V>(&mut self, seed: V) -> std::result::Result<V::Value, Self::Error> where V: DeserializeSeed<'de> {
|
|
seed.deserialize(&mut *self.de)
|
|
}
|
|
}
|
|
|
|
|
|
#[test]
|
|
fn test_ints() -> Result<()> {
|
|
// #[derive(Deserialize, PartialEq, Debug)]
|
|
// struct Test {
|
|
// int: u32,
|
|
// seq: Vec<String>,
|
|
// }
|
|
|
|
let b = vec![7];
|
|
assert_eq!( 7u8, from_bytes(vec![7u8])?);
|
|
|
|
|
|
// let j = r#"{"int":1,"seq":["a","b"]}"#;
|
|
// let expected = Test {
|
|
// int: 1,
|
|
// seq: vec!["a".to_owned(), "b".to_owned()],
|
|
// };
|
|
// assert_eq!(expected, from_str(j).unwrap());
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_struct_de() -> Result<()> {
|
|
#[derive(Serialize, Deserialize, PartialEq, Debug)]
|
|
struct Test {
|
|
int: u32,
|
|
seq: Vec<String>,
|
|
}
|
|
let expected = Test {
|
|
int: 1,
|
|
seq: vec!["a".to_owned(), "b".to_owned()],
|
|
};
|
|
|
|
let packed = to_bytes(&expected)?;
|
|
println!("::{}", to_dump(&packed));
|
|
let unpacked: Test = from_bytes(packed)?;
|
|
println!("::{:?}", unpacked);
|
|
Ok(())
|
|
|
|
// let j = r#"{"int":1,"seq":["a","b"]}"#;
|
|
// assert_eq!(expected, from_str(j).unwrap());
|
|
} |