Enum Innards

pub enum Innards {
    Struct {
        fields: &'static [Field],
    },
    TupleStruct {
        fields: &'static [Field],
    },
    Tuple {
        fields: &'static [Field],
    },
    Map {
        vtable: MapVTable,
        value_shape: ShapeDesc,
    },
    List {
        vtable: ListVTable,
        item_shape: ShapeDesc,
    },
    Transparent(ShapeDesc),
    Scalar(Scalar),
    Enum {
        variants: &'static [Variant],
        repr: EnumRepr,
    },
}

The shape of a schema: is it more map-shaped, array-shaped, scalar-shaped?

Variants

Struct

Struct with statically-known, named fields

e.g. struct Struct { field: u32 }

Fields

fields: &'static [Field]

all fields, in declaration order (not necessarily in memory order)

TupleStruct

Tuple-struct, with numbered fields

e.g. struct TupleStruct(u32, u32);

Fields

fields: &'static [Field]

all fields, in declaration order (not necessarily in memory order)

Tuple

Tuple, with numbered fields

e.g. (u32, u32);

Fields

fields: &'static [Field]

all fields, in declaration order (not necessarily in memory order)

Map

Map — keys are dynamic (and strings, sorry), values are homogeneous

e.g. Map<String, T>

Fields

vtable: MapVTable

vtable for interacting with the map

value_shape: ShapeDesc

shape of the values in the map (keys must be String, sorry)

List

Ordered list of heterogenous values, variable size

e.g. Vec<T>

Fields

vtable: ListVTable

vtable for interacting with the list

item_shape: ShapeDesc

shape of the items in the list

Transparent(ShapeDesc)

Transparent — forwards to another known schema

e.g. #[repr(transparent)] struct Transparent<T>(T);

Scalar(Scalar)

Scalar — known based type

e.g. u32, String, bool

Enum

Enum with variants

e.g. enum Enum { Variant1, Variant2 }

Fields

variants: &'static [Variant]

all variants for this enum

repr: EnumRepr

representation of the enum

Trait Implementations

impl Clone for Innards

fn clone(&self) -> Innards

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Innards

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

Formats the value using the given formatter.

impl Hash for Innards

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Innards

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Innards

impl Eq for Innards

impl StructuralPartialEq for Innards