Struct salvo_oapi::Components

#[non_exhaustive]
pub struct Components {
    pub schemas: BTreeMap<String, RefOr<Schema>>,
    pub responses: Responses,
    pub security_schemes: BTreeMap<String, SecurityScheme>,
}

Implements OpenAPI Components Object which holds supported reusable objects.

Components can hold either reusable types themselves or references to other reusable types.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

schemas: BTreeMap<String, RefOr<Schema>>

Map of reusable OpenAPI Schema Objects.

responses: Responses

Map of reusable response name, to OpenAPI Response Objects or OpenAPI References to OpenAPI Response Objects.

security_schemes: BTreeMap<String, SecurityScheme>

Map of reusable OpenAPI Security Scheme Objects.

Implementations

impl Components

pub fn new() -> Self

Construct a new empty Components. This is effectively same as calling Components::default.

pub fn add_security_scheme<N: Into<String>, S: Into<SecurityScheme>>( self, name: N, security_schema: S ) -> Self

Add SecurityScheme to Components

Accepts two arguments where first is the name of the SecurityScheme. This is later when referenced by SecurityRequirements. Second parameter is the SecurityScheme.

pub fn add_security_schemes_from_iter<I: IntoIterator<Item = (N, S)>, N: Into<String>, S: Into<SecurityScheme>>( self, schemas: I ) -> Self

Add iterator of SecuritySchemes to Components.

Accepts two arguments where first is the name of the SecurityScheme. This is later when referenced by SecurityRequirements. Second parameter is the SecurityScheme.

pub fn add_schema<S: Into<String>, I: Into<RefOr<Schema>>>( self, name: S, schema: I ) -> Self

Add Schema to Components.

Accepts two arguments where first is name of the schema and second is the schema itself.

pub fn schemas_from_iter<I, C, S>(self, schemas: I) -> Selfwhere I: IntoIterator<Item = (S, C)>, C: Into<RefOr<Schema>>, S: Into<String>,

Add Schemas from iterator.

Examples

Components::new().schemas_from_iter([(
    "Pet",
    Schema::from(
        Object::new()
            .property(
                "name",
                Object::new().schema_type(SchemaType::String),
            )
            .required("name")
    ),
)]);

pub fn response<S: Into<String>, R: Into<RefOr<Response>>>( self, name: S, response: R ) -> Self

Add a new response and returns self.

pub fn extend_responses<I: IntoIterator<Item = (S, R)>, S: Into<String>, R: Into<RefOr<Response>>>( self, responses: I ) -> Self

Extends responses with the contents of an iterator.

pub fn security_scheme<N: Into<String>, S: Into<SecurityScheme>>( self, name: N, security_schema: S ) -> Self

Add SecurityScheme to Components.

Accepts two arguments where first is the name of the SecurityScheme. This is later when referenced by SecurityRequirements. Second parameter is the SecurityScheme.

pub fn append(&mut self, other: &mut Components)

Moves all elements from other into self, leaving other empty.

If a key from other is already present in self, the respective value from self will be overwritten with the respective value from other.

pub fn is_empty(&self) -> bool

Returns true if instance contains no elements.

Trait Implementations

impl Clone for Components

fn clone(&self) -> Components

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Components

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

Formats the value using the given formatter.

impl Default for Components

fn default() -> Components

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Components

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

Deserialize this value from the given Serde deserializer.

impl PartialEq<Components> for Components

fn eq(&self, other: &Components) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Components

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 Components