Enum Format

pub enum Format {
    Incomplete {
        debug: String,
    },
    TypeName {
        ident: String,
        generics: Vec<Format>,
    },
    Unit,
    Bool,
    I8,
    I16,
    I32,
    I64,
    I128,
    ISIZE,
    U8,
    U16,
    U32,
    U64,
    U128,
    USIZE,
    F32,
    F64,
    Char,
    Str,
    Bytes,
    Option(Box<Format>),
    Never,
    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. This is just the path respecting serde names into the container It gets replaced by the knowledge

Variants

Incomplete

Fields

debug: String

TypeName

The name of a container.

Fields

ident: String

generics: Vec<Format>

Unit

Bool

I8

I16

I32

I64

I128

ISIZE

U8

U16

U32

U64

U128

USIZE

F32

F64

Char

Str

Bytes

Option(Box<Format>)

The format of Option<T>.

Never

Never actually instantiated

Seq(Box<Format>)

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

Map

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

Fields

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

content: Box<Format>

size: usize

Implementations

impl Format

pub fn is_primitive(&self) -> bool

pub fn is_typename(&self) -> Option<(&str, &[Format])>

pub fn as_ident(&self) -> Cow<'static, str>

pub fn replace_incomplete(&mut self, replacement: Format)

Trait Implementations

impl Debug for Format

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

Formats the value using the given formatter.

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.