Struct NoApi 

pub struct NoApi<T>(pub T);

Available on crate feature openapi only.

A wrapper type that allows using non-OpenAPI handlers and request parameters in OpenAPI routes.

If you need an extractor or a handler that does not implement AsApiOperation/ApiOperationPart, you can wrap it in a NoApi to indicate that it should just be ignored during OpenAPI generation.

Examples

use cot::openapi::NoApi;
use cot::request::RequestHead;
use cot::request::extractors::FromRequestHead;
use cot::response::Response;
use cot::router::Route;
use cot::router::method::openapi::api_get;

struct MyExtractor;
impl FromRequestHead for MyExtractor {
    async fn from_request_head(head: &RequestHead) -> cot::Result<Self> {
        // ...
    }
}

async fn handler(NoApi(extractor): NoApi<MyExtractor>) -> cot::Result<Response> {
    // MyExtractor doesn't have to implement ApiOperationPart and
    // doesn't show up in the OpenAPI spec
}

let router =
    cot::router::Router::with_urls([Route::with_api_handler("/with_api", api_get(handler))]);

use cot::openapi::NoApi;
use cot::response::Response;
use cot::router::Route;
use cot::router::method::openapi::api_get;

async fn handler_with_openapi() -> cot::Result<Response> {
    // ...
}
async fn handler_without_openapi() -> cot::Result<Response> {
    // ...
}

let router = cot::router::Router::with_urls([Route::with_api_handler(
    "/with_api",
    // POST will be ignored in OpenAPI spec
    api_get(handler_with_openapi).post(NoApi(handler_without_openapi)),
)]);

Tuple Fields

0: T

Trait Implementations

impl<T> ApiOperationPart for NoApi<T>

fn modify_api_operation( operation: &mut Operation, route_context: &RouteContext<'_>, schema_generator: &mut SchemaGenerator, )

Modify the OpenAPI operation object.

impl<T> AsApiOperation for NoApi<T>

fn as_api_operation( &self, _route_context: &RouteContext<'_>, _schema_generator: &mut SchemaGenerator, ) -> Option<Operation>

Returns the OpenAPI operation for the route.

impl<T: Clone> Clone for NoApi<T>

fn clone(&self) -> NoApi<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for NoApi<T>

impl<T: Debug> Debug for NoApi<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for NoApi<T>

impl<T: FromRequest> FromRequest for NoApi<T>

async fn from_request(head: &RequestHead, body: Body) -> Result<Self>

Extracts data from the request.

impl<T: FromRequestHead> FromRequestHead for NoApi<T>

async fn from_request_head(head: &RequestHead) -> Result<Self>

Extracts data from the request head.

impl<T: Hash> Hash for NoApi<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Ord> Ord for NoApi<T>

fn cmp(&self, other: &NoApi<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for NoApi<T>

fn eq(&self, other: &NoApi<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialOrd> PartialOrd for NoApi<T>

fn partial_cmp(&self, other: &NoApi<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<HandlerParams, H> RequestHandler<HandlerParams> for NoApi<H>

where H: RequestHandler<HandlerParams>,

fn handle( &self, request: Request, ) -> impl Future<Output = Result<Response>> + Send

Handle the request and returns a response.

impl<T: PartialEq> StructuralPartialEq for NoApi<T>