Struct Deserializer 

pub struct Deserializer<R> { /* private fields */ }

A structure that deserializes JSON into Rust values.

Implementations

impl<'de, R: Reader<'de>> Deserializer<R>

pub fn new(read: R) -> Self

Create a new deserializer.

pub fn use_rawnumber(self) -> Self

Parse all number as crate::RawNumber.

Example

use sonic_rs::{Deserializer, Value};
let json = r#"{"a":1.2345678901234567890123}"#;
let mut de = Deserializer::from_str(json).use_rawnumber();
let value: Value = de.deserialize().unwrap();
let out = sonic_rs::to_string(&value).unwrap();
assert_eq!(json, out);

pub fn utf8_lossy(self) -> Self

Allow to parse JSON with invalid UTF-8 and UTF-16 characters. Will replace them with \uFFFD (displayed as �).

Example

use sonic_rs::{Deserializer, Value};
let data = [
    &[b'\"', 0xff, b'\"'][..],         // invalid UTF8 char in string
    br#"{"a":"\ud800","b":"\udc00"}"#, // invalid UTF16 surrogate pair
];
let expect = [r#""�""#, r#"{"a":"�","b":"�"}"#];

let mut exp = expect.iter();
for json in data {
    let mut de = Deserializer::from_slice(json).utf8_lossy();
    let value: Value = de.deserialize().unwrap();
    let out = sonic_rs::to_string(&value).unwrap();
    assert_eq!(&out, exp.next().unwrap());
}

pub fn deserialize<T>(&mut self) -> Result<T>

where T: Deserialize<'de>,

Deserialize a JSON stream to a Rust data structure.

It can be used repeatedly and we do not check trailing chars after deserilalized.

Example

use sonic_rs::Deserializer;

let multiple_json = r#"{"a": 123, "b": "foo"} true [1, 2, 3] wrong chars"#;

let mut deserializer = Deserializer::from_json(multiple_json);

let val: Value = deserializer.deserialize().unwrap();
assert_eq!(val["a"].as_i64().unwrap(), 123);
assert_eq!(val["b"].as_str().unwrap(), "foo");

let val: bool = deserializer.deserialize().unwrap();
assert_eq!(val, true);

let val: Vec<u8> = deserializer.deserialize().unwrap();
assert_eq!(val, &[1, 2, 3]);

// encounter the wrong chars in json
assert!(deserializer.deserialize::<Value>().is_err());

pub fn into_stream<T>(self) -> StreamDeserializer<'de, T, R>

Convert Deserializer to a StreamDeserializer.

pub fn end(&mut self) -> Result<()>

The Deserializer::end method should be called after a value has been fully deserialized. This allows the Deserializer to validate that the input stream is at the end or that it only has trailing whitespace.

impl<'de> Deserializer<Read<'de>>

pub fn from_json<I: JsonInput<'de>>(input: I) -> Self

Create a new deserializer from a json input JsonInput.

pub fn from_str(s: &'de str) -> Self

Create a new deserializer from a string.

pub fn from_slice(s: &'de [u8]) -> Self

Create a new deserializer from a string slice.

impl<'de, R: Reader<'de>> Deserializer<R>

pub fn end_seq(&mut self) -> Result<()>

pub fn end_map(&mut self) -> Result<()>

Trait Implementations

impl<'de, 'a, R: Reader<'de>> Deserializer<'de> for &'a mut Deserializer<R>

fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Parses a JSON string as bytes. Note that this function does not check whether the bytes represent a valid UTF-8 string.

Followed as serde_json.

fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Parses a null as a None, and any other values as a Some(...).

fn deserialize_newtype_struct<V>( self, name: &'static str, visitor: V, ) -> Result<V::Value>

where V: Visitor<'de>,

Parses a newtype struct as the underlying value.

fn deserialize_enum<V>( self, _name: &str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value>

where V: Visitor<'de>,

Parses an enum as an object like {"$KEY":$VALUE}, where $VALUE is either a straight value, a [..], or a {..}.

type Error = Error

The error type that can be returned if some error occurs during deserialization.

fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input.

fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a bool value.

fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i8 value.

fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i16 value.

fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i32 value.

fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i64 value.

fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u8 value.

fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u16 value.

fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u32 value.

fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u64 value.

fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a f32 value.

fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a f64 value.

fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i128 value.

fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an u128 value.

fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a char value.

fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a string value and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a string value and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a byte array and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a unit value.

fn deserialize_unit_struct<V>( self, _name: &'static str, visitor: V, ) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a unit struct with a particular name.

fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a sequence of values.

fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a sequence of values and knows how many values there are without looking at the serialized data.

fn deserialize_tuple_struct<V>( self, _name: &'static str, _len: usize, visitor: V, ) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a tuple struct with a particular name and number of fields.

fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a map of key-value pairs.

fn deserialize_struct<V>( self, _name: &'static str, _fields: &'static [&'static str], visitor: V, ) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a struct with a particular name and fields.

fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting the name of a struct field or the discriminant of an enum variant.

fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>

where V: Visitor<'de>,

Hint that the Deserialize type needs to deserialize a value whose type doesn’t matter because it is ignored.

fn is_human_readable(&self) -> bool

Determine whether Deserialize implementations should expect to deserialize their human-readable form.