Enum Kind

#[non_exhaustive]
pub enum Kind<Metadata: Default> {
    Struct {
        name: &'static str,
        children: Vec<Entry<Metadata>>,
    },
    Aliased {
        name: &'static str,
        kind: Box<Descriptor<Metadata>>,
    },
    Enum {
        name: &'static str,
        variants: Vec<Variant<Metadata>>,
    },
    Sequence(Box<Descriptor<Metadata>>),
    Option(Box<Descriptor<Metadata>>),
    Mapping(Box<Descriptor<Metadata>>, Box<Descriptor<Metadata>>),
    DateTime,
    String,
    U128,
    I128,
    U64,
    I64,
    U32,
    I32,
    U16,
    I16,
    U8,
    I8,
    F64,
    F32,
    Bool,
    JSON,
    Any,
}

Enum reflecting all supported types

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Struct

The type is a struct

Fields

name: &'static str

Name given to the struct in its declaration

children: Vec<Entry<Metadata>>

List of fields within this struct

Aliased

A struct wrapping a single anonymous field

Fields

name: &'static str

Name given to the struct in its declaration

kind: Box<Descriptor<Metadata>>

The type this alias struct wraps

Enum

A simple no-field enum type

Fields

name: &'static str

Name given to the enum in its declaration

variants: Vec<Variant<Metadata>>

Information about each variant value within this enum

Sequence(Box<Descriptor<Metadata>>)

A list of items of a consistent type

Option(Box<Descriptor<Metadata>>)

An item which is optionally present

Mapping(Box<Descriptor<Metadata>>, Box<Descriptor<Metadata>>)

A pairwise mapping between consistent types with unique keys

DateTime

A field describing a point in time

String

A string

U128

Unsigned 128 bit integer

I128

Signed 128 bit integer

U64

Unsigned 64 bit integer

I64

Signed 64 bit integer

U32

Unsigned 32 bit integer

I32

Signed 32 bit integer

U16

Unsigned 16 bit integer

I16

Signed 16 bit integer

U8

Unsigned 8 bit integer

I8

Signed 8 bit integer

F64

64 bit floating point number

F32

32 bit floating point number

Bool

A boolean value

JSON

A value of unspecified type, that must be limited to json

Any

A value of unspecified type

Implementations

impl<Metadata: MetadataKind> Kind<Metadata>

pub fn name(&self) -> &'static str

Fetch the name of the type

pub fn new_struct( name: &'static str, children: Vec<Entry<Metadata>>, flattened_children: &mut [Descriptor<Metadata>], flattened_metadata: &mut [Metadata], ) -> Self

Construct a type descriptor for a struct with the given name and fields.

Any structs in the flattened_children list will have their fields added to this new struct as if they were members of it. (this corresponds to the ‘flatten’ parameter in serde)

Trait Implementations

impl<Metadata: Clone + Default> Clone for Kind<Metadata>

fn clone(&self) -> Kind<Metadata>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Metadata: Debug + Default> Debug for Kind<Metadata>

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

Formats the value using the given formatter.

impl<Metadata: PartialEq + Default> PartialEq for Kind<Metadata>

fn eq(&self, other: &Kind<Metadata>) -> 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<Metadata: Eq + Default> Eq for Kind<Metadata>

impl<Metadata: Default> StructuralPartialEq for Kind<Metadata>