Enum serde_reflection::Format

pub enum Format {
    Variable(Variable<Format>),
    TypeName(String),
    Unit,
    Bool,
    I8,
    I16,
    I32,
    I64,
    I128,
    U8,
    U16,
    U32,
    U64,
    U128,
    F32,
    F64,
    Char,
    Str,
    Bytes,
    Option(Box<Format>),
    Seq(Box<Format>),
    Map {
        key: Box<Format>,
        value: Box<Format>,
    },
    Tuple(Vec<Format>),
    TupleArray {
        content: Box<Format>,
        size: usize,
    },
}

Serde-based serialization format for anonymous "value" types.

Variants

Variable(Variable<Format>)

A format whose value is initially unknown. Used internally for tracing. Not (de)serializable.

TypeName(String)

The name of a container.

Unit

Bool

I8

I16

I32

I64

I128

U8

U16

U32

U64

U128

F32

F64

Char

Str

Bytes

Option(Box<Format>)

The format of Option<T>.

Seq(Box<Format>)

A sequence, e.g. the format of Vec<Foo>.

Map

A map, e.g. the format of BTreeMap<K, V>.

Fields of Map

key: Box<Format>value: Box<Format>

Tuple(Vec<Format>)

A tuple, e.g. the format of (Foo, Bar).

TupleArray

Alias for (Foo, ... Foo). E.g. the format of [Foo; N].

Fields of TupleArray

content: Box<Format>size: usize

Implementations

impl Format

pub fn unknown() -> Self

Return a format made of a fresh variable with no known value.

Trait Implementations

impl Clone for Format

fn clone(&self) -> Format

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Format

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

Formats the value using the given formatter.

impl Default for Format

fn default() -> Self

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for Format

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Eq for Format

impl FormatHolder for Format

fn visit<'a>(
    &'a self,
    f: &mut dyn FnMut(&'a Format) -> Result<()>
) -> Result<()>

Visit all the formats in self in a depth-first way. Variables are not supported and will cause an error.

fn visit_mut(
    &mut self,
    f: &mut dyn FnMut(&mut Format) -> Result<()>
) -> Result<()>

Mutably visit all the formats in self in a depth-first way. * Replace variables (if any) with their known values then apply the visiting function f. * Return an error if any variable has still an unknown value (thus cannot be removed).

fn unify(&mut self, format: Format) -> Result<()>

Unify the newly "traced" value format into the current format. Note that there should be no TupleArrays at this point.

fn is_unknown(&self) -> bool

Whether this format is a variable with no known value yet.

fn normalize(&mut self) -> Result<()>

Finalize the formats within self by removing variables and making sure that all eligible tuples are compressed into a TupleArray. Return an error if any variable has an unknown value.

fn reduce(&mut self)

Attempt to remove known variables within self. Silently abort if some variables have unknown values.

impl PartialEq<Format> for Format

fn eq(&self, other: &Format) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Format) -> bool

This method tests for !=.

impl Serialize for Format

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralEq for Format

impl StructuralPartialEq for Format