Struct serde_reflection::Tracer

pub struct Tracer { /* fields omitted */ }

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: ?Sized>(
    &mut self,
    samples: &mut Samples,
    value: &T
) -> Result<(Format, Value)> where
    T: 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.