Struct serde_json::Deserializer

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

A structure that deserializes JSON into Rust values.

Methods

impl<R> Deserializer<R> where R: Read

fn new(read: R) -> Self

Create a JSON deserializer from one of the possible serde_json input sources.

Typically it is more convenient to use one of these methods instead:

• Deserializer::from_str
• Deserializer::from_bytes
• Deserializer::from_iter
• Deserializer::from_reader

impl<I> Deserializer<IteratorRead<I>> where I: Iterator<Item=Result<u8>>

fn from_iter(iter: I) -> Self

Creates a JSON deserializer from a std::iter::Iterator.

impl<R> Deserializer<IoRead<R>> where R: Read

fn from_reader(reader: R) -> Self

Creates a JSON deserializer from an io::Read.

impl<'a> Deserializer<SliceRead<'a>>

fn from_slice(bytes: &'a [u8]) -> Self

Creates a JSON deserializer from a &[u8].

impl<'a> Deserializer<StrRead<'a>>

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

Creates a JSON deserializer from a &str.

impl<R: Read> Deserializer<R>

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.

fn into_iter<T>(self) -> StreamDeserializer<R, T> where T: Deserialize

Turn a JSON deserializer into an iterator over values of type T.

Trait Implementations

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

type Error = Error

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

fn deserialize<V>(self, visitor: V) -> Result<V::Value> where V: Visitor

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

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

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

fn deserialize_newtype_struct<V>(self,
                                 _name: &str,
                                 visitor: V)
                                 -> Result<V::Value> where V: Visitor

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

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

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

Parses a JSON string as bytes. Note that this function does not check whether the bytes represent valid unicode code points.

The JSON specification requires that strings only contain valid unicode characters. To deal with non-conforming JSON, you may use this function, which attempts to parse a string without checking whether the bytes represent valid unicode code points.

Escape sequences are processed as usual, and for \uXXXX escapes it is still checked if the hex number represents a valid unicode code point.

Example usage

You can use this to parse JSON strings containing non-unicode bytes:

let bytes = serde::bytes::ByteBuf::from(b"some raw bytes: \xe5\x00\xe5".to_vec());
let parsed = serde_json::from_slice(  b"\"some raw bytes: \xe5\x00\xe5\"").unwrap();
 
assert_eq!(bytes, parsed);

\u escape sequences with invalid unicode code points still fail to parse:

let json = "\"invalid unicode surrogate: \\uD801\"";
let parsed: Result<serde::bytes::ByteBuf, _> = serde_json::from_str(json);
assert!(parsed.is_err(), "{} should not parse: {:?}", json, parsed);

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

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_bool<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting a bool value.

fn deserialize_u8<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting a u8 value.

fn deserialize_u16<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting a u16 value.

fn deserialize_u32<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting a u32 value.

fn deserialize_u64<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting a u64 value.

fn deserialize_i8<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting an i8 value.

fn deserialize_i16<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting an i16 value.

fn deserialize_i32<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting an i32 value.

fn deserialize_i64<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting an i64 value.

fn deserialize_f32<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting a f32 value.

fn deserialize_f64<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting a f64 value.

fn deserialize_char<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting a char value.

fn deserialize_str<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

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, Self::Error> where __V: Visitor

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_unit<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting a unit value.

fn deserialize_seq<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

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

fn deserialize_seq_fixed_size<__V>(self,
                                   _: usize,
                                   visitor: __V)
                                   -> Result<__V::Value, Self::Error> where __V: Visitor

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_map<__V>(self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: Visitor

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

fn deserialize_unit_struct<__V>(self,
                                _: &'static str,
                                visitor: __V)
                                -> Result<__V::Value, Self::Error> where __V: Visitor

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

fn deserialize_tuple_struct<__V>(self,
                                 _: &'static str,
                                 _: usize,
                                 visitor: __V)
                                 -> Result<__V::Value, Self::Error> where __V: Visitor

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

fn deserialize_struct<__V>(self,
                           _: &'static str,
                           _: &'static [&'static str],
                           visitor: __V)
                           -> Result<__V::Value, Self::Error> where __V: Visitor

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

fn deserialize_struct_field<__V>(self,
                                 visitor: __V)
                                 -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting the name of a struct field.

fn deserialize_tuple<__V>(self,
                          _: usize,
                          visitor: __V)
                          -> Result<__V::Value, Self::Error> where __V: Visitor

Hint that the Deserialize type is expecting a tuple value with a particular number of elements.

fn deserialize_ignored_any<__V>(self,
                                visitor: __V)
                                -> Result<__V::Value, Self::Error> where __V: Visitor

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