Enum BasicType

pub enum BasicType {
    Object,
    String,
    Integer,
    Number,
    Boolean,
    Array,
    Null,
}

Represents data type fragment of Schema.

BasicType is used to create a SchemaType that defines the type of the Schema. SchemaType can be created from a single BasicType or multiple BasicTypes according to the OpenAPI 3.1 spec. Since the OpenAPI 3.1 is fully compatible with JSON schema the definiton of the type property comes from JSON Schema type.

Examples

Create nullable string SchemaType

let _: SchemaType = [BasicType::String, BasicType::Null].into_iter().collect();

Create string SchemaType

let _ = SchemaType::basic(BasicType::String);

Variants

Object

Used with Object to describe schema that has properties describing fields. have

String

Indicates string type of content. Used with Object on a string field.

Integer

Indicates integer type of content. Used with Object on a number field.

Number

Indicates floating point number type of content. Used with Object on a number field.

Boolean

Indicates boolean type of content. Used with Object on a bool field.

Array

Used with Array. Indicates array type of content.

Null

Null type. Used together with other type to indicate nullable values.

Trait Implementations

impl Clone for BasicType

fn clone(&self) -> BasicType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BasicType

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

Formats the value using the given formatter.

impl Default for BasicType

fn default() -> BasicType

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BasicType

fn deserialize<__D>( __deserializer: __D, ) -> Result<BasicType, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<BasicType> for SchemaType

fn from(value: BasicType) -> SchemaType

Converts to this type from the input type.

impl FromIterator<BasicType> for SchemaType

fn from_iter<T>(iter: T) -> SchemaType

where T: IntoIterator<Item = BasicType>,

Creates a value from an iterator.

impl PartialEq for BasicType

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for BasicType

impl StructuralPartialEq for BasicType