Struct Tracer 

pub struct Tracer { /* private fields */ }

Structure to drive the tracing of Serde serialization and deserialization. This typically aims at computing a Registry.

Implementations

impl Tracer

pub fn new(config: TracerConfig) -> Self

Start tracing deserialization.

pub fn trace_value<T>( &mut self, samples: &mut Samples, value: &T, ) -> Result<(Format, Value)>

where T: ?Sized + Serialize,

Trace the serialization of a particular value.

• Nested containers will be added to the tracing registry, indexed by their (non-qualified) name.
• Sampled Rust values will be inserted into samples to benefit future calls to the trace_type_* methods.

pub fn trace_type_once<'de, T>( &mut self, samples: &'de Samples, ) -> Result<(Format, T)>

where T: Deserialize<'de>,

Trace a single deserialization of a particular type.

• Nested containers will be added to the tracing registry, indexed by their (non-qualified) name.
• As a byproduct of deserialization, we also return a value of type T.
• Tracing deserialization of a type may fail if this type or some dependencies have implemented a custom deserializer that validates data. The solution is to make sure that samples holds enough sampled Rust values to cover all the custom types.

pub fn trace_type_once_with_seed<'de, S>( &mut self, samples: &'de Samples, seed: S, ) -> Result<(Format, S::Value)>

where S: DeserializeSeed<'de>,

Same as trace_type_once for seeded deserialization.

pub fn trace_type<'de, T>( &mut self, samples: &'de Samples, ) -> Result<(Format, Vec<T>)>

where T: Deserialize<'de>,

Same as trace_type_once but if T is an enum, we repeat the process until all variants of T are covered. We accumulate and return all the sampled values at the end.

pub fn trace_simple_type<'de, T>(&mut self) -> Result<(Format, Vec<T>)>

where T: Deserialize<'de>,

Trace a type T that is simple enough that no samples of values are needed.

• If T is an enum, the tracing iterates until all variants of T are covered.
• Accumulate and return all the sampled values at the end. This is merely a shortcut for self.trace_type with a fixed empty set of samples.

pub fn trace_type_with_seed<'de, S>( &mut self, samples: &'de Samples, seed: S, ) -> Result<(Format, Vec<S::Value>)>

where S: DeserializeSeed<'de> + Clone,

Same as trace_type for seeded deserialization.

pub fn registry(self) -> Result<Registry>

Finish tracing and recover a map of normalized formats. Returns an error if we detect incompletely traced types. This may happen in a few of cases:

• We traced serialization of user-provided values but we are still missing the content of an option type, the content of a sequence type, the key or the value of a dictionary type.
• We traced deserialization of an enum type but we detect that some enum variants are still missing.

pub fn registry_unchecked(self) -> Registry

Same as registry but always return a value, even if we detected issues. This should only be use for debugging.

Trait Implementations

impl Debug for Tracer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.