Enum Type

pub enum Type {
    I8,
    I16,
    I32,
    I64,
    U8,
    U16,
    U32,
    U64,
    F32,
    F64,
    Bool,
    String,
    Datetime,
    Bytes,
    Named(String),
    List {
        ty: Box<Type>,
    },
    Optional {
        ty: Box<Type>,
    },
    Map {
        key: Box<Type>,
        value: Box<Type>,
    },
    Link {
        schemas: Vec<String>,
    },
    Object,
    AnonymousStruct(Vec<Field>),
}

Enum of valid types.

Variants

I8

I8 type.

I16

I16 type.

I32

I32 type.

I64

I64 type.

U8

u8 type.

U16

u16 type.

U32

u32 type.

U64

u64 type.

F32

f32 type.

F64

f64 type.

Bool

Boolean type.

String

String type.

Datetime

Date type.

Bytes

Raw bytes.

Named(String)

A reference to another type.

List

A list type

Fields

ty: Box<Type>

The type of the list’s elements

Optional

A type representing an optional value.

Fields

ty: Box<Type>

The actual type that is optional.

Map

A HashMap-like type.

Fields

key: Box<Type>

The type of the map’s keys.

value: Box<Type>

The type of the map’s values.

Link

👎Deprecated: Links are deprecated, use the require/provides interface instead.

A type representing a link to another collection.

Fields

schemas: Vec<String>

👎Deprecated: Links are deprecated, use the require/provides interface instead.

The schemas that must be provided with the linked collection.

Object

A JSON-like key/value map.

AnonymousStruct(Vec<Field>)

An inline, anonymous struct interface.

Tuple Fields

0: Vec<Field>

A list of fields in the struct.

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Type

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Type

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

Formats the value using the given formatter.

impl FromStr for Type

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for Type

fn eq(&self, other: &Type) -> 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 Serialize for Type

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Type

impl StructuralPartialEq for Type