Enum TypeSignature

pub enum TypeSignature {
    I8,
    I16,
    I32,
    I64,
    U8,
    U16,
    U32,
    U64,
    F32,
    F64,
    Bool,
    String,
    Datetime,
    Bytes,
    Value,
    Internal(InternalType),
    Ref {
        reference: String,
    },
    List {
        element: Box<TypeSignature>,
    },
    Optional {
        option: Box<TypeSignature>,
    },
    Map {
        key: Box<TypeSignature>,
        value: Box<TypeSignature>,
    },
    Link {
        schemas: Vec<String>,
    },
    Struct,
}

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.

Value

Any valid value.

Internal(InternalType)

An internal type.

Ref

A reference to another type.

Fields

reference: String

The reference string

List

A list type

Fields

element: Box<TypeSignature>

The type of the list’s elements

Optional

A type representing an optional value.

Fields

option: Box<TypeSignature>

The actual type that is optional.

Map

A HashMap-like type.

Fields

key: Box<TypeSignature>

The type of the map’s keys.

value: Box<TypeSignature>

The type of the map’s values.

Link

A type representing a link to another collection.

Fields

schemas: Vec<String>

The schemas that must be provided with the linked collection.

Struct

A JSON-like key/value map.

Trait Implementations

impl Clone for TypeSignature

fn clone(&self) -> TypeSignature

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeSignature

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TypeSignature

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromStr for TypeSignature

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 TypeSignature

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TypeSignature