Struct Schema 

pub struct Schema {
    pub type: i32,
    pub format: String,
    pub description: String,
    pub nullable: bool,
    pub enum: Vec<String>,
    pub items: Option<Box<Schema>>,
    pub max_items: i64,
    pub min_items: i64,
    pub properties: HashMap<String, Schema>,
    pub required: Vec<String>,
}

The Schema object allows the definition of input and output data types. These types can be objects, but also primitives and arrays. Represents a select subset of an OpenAPI 3.0 schema object.

Fields

type: i32

Required. Data type.

format: String

Optional. The format of the data. This is used only for primitive datatypes. Supported formats: for NUMBER type: float, double for INTEGER type: int32, int64 for STRING type: enum

description: String

Optional. A brief description of the parameter. This could contain examples of use. Parameter description may be formatted as Markdown.

nullable: bool

Optional. Indicates if the value may be null.

enum: Vec<String>

Optional. Possible values of the element of Type.STRING with enum format. For example we can define an Enum Direction as : {type:STRING, format:enum, enum:[“EAST”, NORTH“, “SOUTH”, “WEST”]}

items: Option<Box<Schema>>

Optional. Schema of the elements of Type.ARRAY.

max_items: i64

Optional. Maximum number of the elements for Type.ARRAY.

min_items: i64

Optional. Minimum number of the elements for Type.ARRAY.

properties: HashMap<String, Schema>

Optional. Properties of Type.OBJECT.

required: Vec<String>

Optional. Required properties of Type.OBJECT.

Implementations

impl Schema

pub fn new(typ: SchemaType) -> Self

Constructs a new schema for the specified primitive type.

pub fn new_object() -> Self

Creates a new schema for an object type.

pub fn new_array() -> Self

Creates a new schema for an array type.

pub fn new_number() -> Self

Creates a new schema for a number type.

pub fn new_integer() -> Self

Creates a new schema for an integer type.

pub fn new_string() -> Self

Creates a new schema for a string type.

pub fn format(self, format: SchemaFormat) -> Self

Sets the format of the schema.

This is used for primitive types like int32, int64, float, double, or enum.

pub fn description(self, description: impl Into<String>) -> Self

Sets the description of the schema.

The description can be formatted as Markdown.

pub fn nullable(self, nullable: bool) -> Self

Sets whether the schema value may be null.

pub fn into_enum<I, S>(self, enum: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Sets the possible enum values for a String type.

This method automatically sets the schema’s type to String and its format to Enum. The values provided will be added to the enum field.

Example

let enum_schema = Schema::new_string()
    .into_enum(["EAST", "NORTH", "SOUTH", "WEST"]);

pub fn items(self, items: Schema) -> Self

Sets the schema for the elements of an Array type.

This method is only effective when the schema’s type is Array. It specifies the structure of the items contained within the array.

Example

For a Vec<String>, you would define the schema like this:

let string_array_schema = Schema::new_array()
    .items(Schema::new_string());

pub fn max_items(self, max_items: i64) -> Self

Sets the maximum number of elements for an Array schema.

This method is only effective when the schema’s type is Array.

pub fn min_items(self, min_items: i64) -> Self

Sets the minimum number of elements for an Array schema.

This method is only effective when the schema’s type is Array.

pub fn property(self, name: impl Into<String>, schema: Schema) -> Self

Adds a single property to an Object schema.

This method is a convenience for adding a single key-value pair to the properties map. It’s only effective when the schema’s type is Object.

Arguments

• name - The name of the property.
• schema - The schema definition for the property.

pub fn properties<I, S>(self, properties: I) -> Self

where I: IntoIterator<Item = (S, Schema)>, S: Into<String>,

Sets the properties for an Object schema.

This method is only effective when the schema’s type is Object.

Arguments

• properties - An iterator of key-value pairs where the key is the property name and the value is the property’s Schema.

pub fn required_field(self, name: impl Into<String>) -> Self

Adds a required field to an Object schema.

This method is only effective when the schema’s type is Object.

Arguments

• name - The name of the property that is now required.

pub fn required<I, S>(self, required: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Sets the list of all required properties for an Object schema.

This method is only effective when the schema’s type is Object.

Arguments

• required - An iterator of property names that must be present.

impl Schema

pub fn type(&self) -> Type

Returns the enum value of type, or the default if the field is set to an invalid enum value.

pub fn set_type(&mut self, value: Type)

Sets type to the provided enum value.

Trait Implementations

impl Clone for Schema

fn clone(&self) -> Schema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Schema

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

Formats the value using the given formatter.

impl Default for Schema

fn default() -> Self

Returns the “default value” for a type.

impl Message for Schema

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for Schema

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