Struct serde_json::Deserializer[−][src]

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

A structure that deserializes JSON into Rust values.

Implementations

impl<'de, R> Deserializer<R> where
    R: Read<'de>, [src]

pub fn new(read: R) -> Self[src]

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_slice
  • Deserializer::from_reader

impl<R> Deserializer<IoRead<R>> where
    R: Read, [src]

pub fn from_reader(reader: R) -> Self[src]

Creates a JSON deserializer from an io::Read.

Reader-based deserializers do not support deserializing borrowed types like &str, since the std::io::Read trait has no non-copying methods – everything it does involves copying bytes out of the data source.

impl<'a> Deserializer<SliceRead<'a>>[src]

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

Creates a JSON deserializer from a &[u8].

impl<'a> Deserializer<StrRead<'a>>[src]

pub fn from_str(s: &'a str) -> Self[src]

Creates a JSON deserializer from a &str.

impl<'de, R: Read<'de>> Deserializer<R>[src]

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

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.

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

Notable traits for StreamDeserializer<'de, R, T>

impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T> where
    R: Read<'de>,
    T: Deserialize<'de>,  type Item = Result<T>;
 where
    T: Deserialize<'de>, [src]

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

pub fn disable_recursion_limit(&mut self)[src]

Parse arbitrarily deep JSON structures without any consideration for overflowing the stack.

You will want to provide some other way to protect against stack overflows, such as by wrapping your Deserializer in the dynamically growing stack adapter provided by the serde_stacker crate. Additionally you will need to be careful around other recursive operations on the parsed result which may overflow the stack after deserialization has completed, including, but not limited to, Display and Debug and Drop impls.

This method is only available if serde_json is built with the "unbounded_depth" feature.

Examples

use serde::Deserialize;
use serde_json::Value;

fn main() {
    let mut json = String::new();
    for _ in 0..10000 {
        json = format!("[{}]", json);
    }

    let mut deserializer = serde_json::Deserializer::from_str(&json);
    deserializer.disable_recursion_limit();
    let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
    let value = Value::deserialize(deserializer).unwrap();

    carefully_drop_nested_arrays(value);
}

fn carefully_drop_nested_arrays(value: Value) {
    let mut stack = vec![value];
    while let Some(value) = stack.pop() {
        if let Value::Array(array) = value {
            stack.extend(array);
        }
    }
}

Trait Implementations

impl<'de, 'a, R: Read<'de>> Deserializer<'de> for &'a mut Deserializer<R>[src]

type Error = Error

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

fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> where
    V: Visitor<'de>, [src]

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

The relevant part of the JSON specification is Section 8.2 of RFC 7159:

When all the strings represented in a JSON text are composed entirely of Unicode characters (however escaped), then that JSON text is interoperable in the sense that all software implementations that parse it will agree on the contents of names and of string values in objects and arrays.

However, the ABNF in this specification allows member names and string values to contain bit sequences that cannot encode Unicode characters; for example, “\uDEAD” (a single unpaired UTF-16 surrogate). Instances of this have been observed, for example, when a library truncates a UTF-16 string without checking whether the truncation split a surrogate pair. The behavior of software that receives JSON texts containing such values is unpredictable; for example, implementations might return different values for the length of a string value or even suffer fatal runtime exceptions.

The behavior of serde_json is specified to fail on non-UTF-8 strings when deserializing into Rust UTF-8 string types such as String, and succeed with non-UTF-8 bytes when deserializing using this method.

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

Examples

You can use this to parse JSON strings containing invalid UTF-8 bytes.

use serde_bytes::ByteBuf;

fn look_at_bytes() -> Result<(), serde_json::Error> {
    let json_data = b"\"some bytes: \xe5\x00\xe5\"";
    let bytes: ByteBuf = serde_json::from_slice(json_data)?;

    assert_eq!(b'\xe5', bytes[12]);
    assert_eq!(b'\0', bytes[13]);
    assert_eq!(b'\xe5', bytes[14]);

    Ok(())
}

Backslash escape sequences like \n are still interpreted and required to be valid, and \u escape sequences are required to represent valid Unicode code points.

use serde_bytes::ByteBuf;

fn look_at_bytes() {
    let json_data = b"\"invalid unicode surrogate: \\uD801\"";
    let parsed: Result<ByteBuf, _> = serde_json::from_slice(json_data);

    assert!(parsed.is_err());

    let expected_msg = "unexpected end of hex escape at line 1 column 35";
    assert_eq!(expected_msg, parsed.unwrap_err().to_string());
}

fn deserialize_option<V>(self, visitor: V) -> Result<V::Value> where
    V: Visitor<'de>, [src]

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<'de>, [src]

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>, [src]

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

Auto Trait Implementations

impl<R> RefUnwindSafe for Deserializer<R> where
    R: RefUnwindSafe, 

impl<R> Send for Deserializer<R> where
    R: Send, 

impl<R> Sync for Deserializer<R> where
    R: Sync, 

impl<R> Unpin for Deserializer<R> where
    R: Unpin, 

impl<R> UnwindSafe for Deserializer<R> where
    R: UnwindSafe, 

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.