Enum TypeDef 

pub enum TypeDef {
    Bool,
    U8,
    U16,
    U32,
    U64,
    U128,
    I8,
    I16,
    I32,
    I64,
    I128,
    Char,
    Str,
    Bytes,
    Sequence(TypeId),
    Map(TypeId, TypeId),
    Array(TypeId, u32),
    Tuple(Vec<TypeId>),
    StructUnit,
    StructNewType(TypeId),
    StructTuple(Vec<TypeId>),
    Struct(Vec<Field>),
    Variant(VariantDef),
    Compact(TypeId),
    BitSequence(TypeId, TypeId),
}

Type definitions that map directly to serde’s data model.

Variants

Bool

U8

U16

U32

U64

U128

I8

I16

I32

I64

I128

Char

Str

Bytes

Vec<u8> serialized as raw bytes

Sequence(TypeId)

Homogeneous sequence with compact-length prefix

Map(TypeId, TypeId)

BTreeMap<K, V>

Array(TypeId, u32)

Fixed-length array [T; N]

Tuple(Vec<TypeId>)

Heterogeneous tuple (T1, T2, ...)

StructUnit

Unit struct (zero fields)

StructNewType(TypeId)

Newtype struct Foo(T)

StructTuple(Vec<TypeId>)

Tuple struct Foo(T1, T2, ...)

Struct(Vec<Field>)

Named-field struct

Variant(VariantDef)

Enum type

Compact(TypeId)

Compact-encoded integer

BitSequence(TypeId, TypeId)

Bit sequence (store, order type IDs)

Trait Implementations

impl Clone for TypeDef

fn clone(&self) -> TypeDef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeDef

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TypeDef

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TypeDef

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

where __S: Serializer,

Serialize this value into the given Serde serializer.