Skip to main content

DeserializerExt

Trait DeserializerExt 

Source
pub trait DeserializerExt<'de>: Deserializer<'de> {
    // Provided methods
    fn deserialize<T, F>(self, callback: F) -> Result<T, Self::Error>
       where T: Deserialize<'de>,
             F: FnMut(&Path<'_>) -> Result<(), Self::Error> { ... }
    fn track(self) -> Builder<Self> { ... }
}
Expand description

Unknown-field handling for any Serde Deserializer.

Import this trait to call .deserialize(callback) or .track() on a deserializer. The adapter supports structs that would otherwise reject unknown fields, including pbjson-generated messages. Known values retain the target type’s deserialization behavior.

Unknown-field tracking does not support #[serde(flatten)]. Paths borrow stack-local nodes and cannot be kept after the callback returns.

Provided Methods§

Source

fn deserialize<T, F>(self, callback: F) -> Result<T, Self::Error>
where T: Deserialize<'de>, F: FnMut(&Path<'_>) -> Result<(), Self::Error>,

Deserializes T, calling callback before each unknown value is consumed.

Return Ok(()) to continue or Self::Error to reject the input. The first callback error is returned unchanged even if nested deserialization uses a different error type or catches the intermediate error. No further callbacks run after rejection. An unknown subtree produces one callback.

use serde::Deserialize;
use serde_unknown::DeserializerExt;

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Config { port: u16 }

let mut deserializer = serde_json::Deserializer::from_str(
    r#"{"port":8080,"future":true}"#,
);
let mut count = 0;
let config: Config = (&mut deserializer).deserialize(|path| {
    assert!(path.matches(&["<root>", "future"]));
    count += 1;
    Ok(())
})?;
deserializer.end()?;
assert_eq!(config.port, 8080);
assert_eq!(count, 1);
Source

fn track(self) -> Builder<Self>

Creates a Builder with neither callback configured.

Use Builder::filter to select unknown values or reject their paths. With the peek feature, Builder::peek can inspect their parsed values. With neither callback, unknown values are consumed directly.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§

Source§

impl<'de, D: Deserializer<'de>> DeserializerExt<'de> for D