# Struct serde_json::de::Deserializer

source · [−]

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

Expand description

A structure that deserializes JSON into Rust values.

## Implementations

source

### impl<'de, R> Deserializer<R> where
R: Read<'de>,

source

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

source

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

source

#### pub fn from_reader(reader: R) -> Self

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.

source

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

source

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

Creates a JSON deserializer from a `&[u8]`.

source

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

source

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

Creates a JSON deserializer from a `&str`.

source

### impl<'de, R: Read<'de>> Deserializer<R>

source

#### 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.

source

#### 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>,

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

## Trait Implementations

source

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

source

#### 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.

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, or unpaired surrogates.

    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. `\u` escape sequences are required to represent a valid Unicode code point or lone surrogate.

    use serde_bytes::ByteBuf;

    fn look_at_bytes() -> Result<(), serde_json::Error> {
        let json_data = b"\"lone surrogate: \\uD801\"";
        let bytes: ByteBuf = serde_json::from_slice(json_data)?;
        let expected = b"lone surrogate: \xED\xA0\x81";
        assert_eq!(expected, bytes.as_slice());
        Ok(())
    }

source

#### 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(...)`.

source

#### fn deserialize_newtype_struct<V>(self, name: &str, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Parses a newtype struct as the underlying value.

source

#### 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. Read more

source

#### 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. Read more

source

#### fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `bool` value.

source

#### fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i8` value.

source

#### fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i16` value.

source

#### fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i32` value.

source

#### fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i64` value.

source

#### fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u8` value.

source

#### fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u16` value.

source

#### fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u32` value.

source

#### fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `u64` value.

source

#### fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `f32` value.

source

#### fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `f64` value.

source

#### fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `i128` value. Read more

source

#### fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting an `u128` value. Read more

source

#### fn deserialize_char<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a `char` value.

source

#### 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`. Read more

source

#### 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`. Read more

source

#### 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`. Read more

source

#### fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value> where
V: Visitor<'de>,

Hint that the `Deserialize` type is expecting a unit value.

source

#### 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. Read more

source

#### 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.

source

#### 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. Read more

source

#### 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. Read more

source

#### 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.

source

#### 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. Read more

source

#### 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. Read more

source

#### 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. Read more

source

#### fn is_human_readable(&self) -> bool

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

## 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

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

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

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.