Struct Components 

#[non_exhaustive]
pub struct Components {
    pub schemas: Schemas,
    pub responses: Responses,
    pub parameters: PropMap<String, RefOr<Parameter>>,
    pub examples: PropMap<String, RefOr<Example>>,
    pub request_bodies: PropMap<String, RefOr<RequestBody>>,
    pub headers: PropMap<String, RefOr<Header>>,
    pub security_schemes: PropMap<String, SecurityScheme>,
    pub links: PropMap<String, RefOr<Link>>,
    pub callbacks: PropMap<String, RefOr<Callback>>,
    pub path_items: PropMap<String, RefOr<PathItem>>,
    pub extensions: PropMap<String, Value>,
}

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: Schemas

Map of reusable OpenAPI Schema Objects.

responses: Responses

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

parameters: PropMap<String, RefOr<Parameter>>

Map of reusable OpenAPI Parameter Objects, indexed by name.

examples: PropMap<String, RefOr<Example>>

Map of reusable OpenAPI Example Objects, indexed by name.

request_bodies: PropMap<String, RefOr<RequestBody>>

Map of reusable OpenAPI Request Body Objects, indexed by name.

headers: PropMap<String, RefOr<Header>>

Map of reusable OpenAPI Header Objects, indexed by header name.

security_schemes: PropMap<String, SecurityScheme>

Map of reusable OpenAPI Security Scheme Objects.

links: PropMap<String, RefOr<Link>>

Map of reusable OpenAPI Link Objects, indexed by name.

callbacks: PropMap<String, RefOr<Callback>>

Map of reusable OpenAPI Callback Objects, indexed by name.

path_items: PropMap<String, RefOr<PathItem>>

Map of reusable OpenAPI Path Item Objects. Added in OpenAPI 3.1; entries here can be referenced from paths or webhooks via RefOr::Ref.

extensions: PropMap<String, Value>

Optional extensions “x-something”

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_scheme: S, ) -> Self

Add SecurityScheme to Components and returns Self.

Accepts two arguments: the name of the SecurityScheme (used later when referenced by SecurityRequirements) and the SecurityScheme itself.

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

Add iterator of SecuritySchemes to Components.

Accepts two arguments: the name of the SecurityScheme (used later when referenced by SecurityRequirements) and the SecurityScheme itself.

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

Add Schema to Components and returns Self.

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

pub fn extend_schemas<I, C, S>(self, schemas: I) -> Self

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

Add Schemas from iterator.

Examples

Components::new().extend_schemas([(
    "Pet",
    Schema::from(
        Object::new()
            .property("name", Object::new().schema_type(BasicType::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 add_parameter<N: Into<String>, P: Into<RefOr<Parameter>>>( self, name: N, parameter: P, ) -> Self

Insert a reusable Parameter (or a Ref to one) and return self.

pub fn add_example<N: Into<String>, E: Into<RefOr<Example>>>( self, name: N, example: E, ) -> Self

Insert a reusable Example (or a Ref to one) and return self.

pub fn add_request_body<N: Into<String>, B: Into<RefOr<RequestBody>>>( self, name: N, request_body: B, ) -> Self

Insert a reusable RequestBody (or a Ref to one) and return self.

pub fn add_header<N: Into<String>, H: Into<RefOr<Header>>>( self, name: N, header: H, ) -> Self

Insert a reusable Header (or a Ref to one) and return self.

pub fn add_link<N: Into<String>, L: Into<RefOr<Link>>>( self, name: N, link: L, ) -> Self

Insert a reusable Link (or a Ref to one) and return self.

pub fn add_callback<N: Into<String>, C: Into<RefOr<Callback>>>( self, name: N, callback: C, ) -> Self

Insert a reusable Callback (or a Ref to one) and return self.

pub fn add_path_item<N: Into<String>, P: Into<RefOr<PathItem>>>( self, name: N, path_item: P, ) -> Self

Insert a reusable PathItem (or a Ref to one) and return self.

Path Item entries in components.pathItems were introduced in OpenAPI 3.1 to support reusable webhooks and shared path operations.

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

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

If a key from other is already present in self, the existing value is kept and the duplicate from other is dropped.

pub fn extensions(self, extensions: PropMap<String, Value>) -> Self

Add openapi extensions (x-something) for Components.

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 duplicate 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 for Components

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