Struct axum::handler::OnMethod

pub struct OnMethod<S, F> { /* fields omitted */ }

A handler Service that accepts requests based on a MethodFilter and allows chaining additional handlers.

Implementations

impl<S, F> OnMethod<S, F>

pub fn any<H, B, T>(self, handler: H) -> OnMethod<IntoService<H, B, T>, Self> where
    H: Handler<B, T>, 

Chain an additional handler that will accept all requests regardless of its HTTP method.

See OnMethod::get for an example.

pub fn connect<H, B, T>(
    self,
    handler: H
) -> OnMethod<IntoService<H, B, T>, Self> where
    H: Handler<B, T>, 

Chain an additional handler that will only accept CONNECT requests.

See OnMethod::get for an example.

pub fn delete<H, B, T>(self, handler: H) -> OnMethod<IntoService<H, B, T>, Self> where
    H: Handler<B, T>, 

Chain an additional handler that will only accept DELETE requests.

See OnMethod::get for an example.

pub fn get<H, B, T>(self, handler: H) -> OnMethod<IntoService<H, B, T>, Self> where
    H: Handler<B, T>, 

Chain an additional handler that will only accept GET requests.

Example

use axum::prelude::*;

async fn handler() {}

async fn other_handler() {}

// Requests to `GET /` will go to `handler` and `POST /` will go to
// `other_handler`.
let app = route("/", post(handler).get(other_handler));

pub fn head<H, B, T>(self, handler: H) -> OnMethod<IntoService<H, B, T>, Self> where
    H: Handler<B, T>, 

Chain an additional handler that will only accept HEAD requests.

See OnMethod::get for an example.

pub fn options<H, B, T>(
    self,
    handler: H
) -> OnMethod<IntoService<H, B, T>, Self> where
    H: Handler<B, T>, 

Chain an additional handler that will only accept OPTIONS requests.

See OnMethod::get for an example.

pub fn patch<H, B, T>(self, handler: H) -> OnMethod<IntoService<H, B, T>, Self> where
    H: Handler<B, T>, 

Chain an additional handler that will only accept PATCH requests.

See OnMethod::get for an example.

pub fn post<H, B, T>(self, handler: H) -> OnMethod<IntoService<H, B, T>, Self> where
    H: Handler<B, T>, 

Chain an additional handler that will only accept POST requests.

See OnMethod::get for an example.

pub fn put<H, B, T>(self, handler: H) -> OnMethod<IntoService<H, B, T>, Self> where
    H: Handler<B, T>, 

Chain an additional handler that will only accept PUT requests.

See OnMethod::get for an example.

pub fn trace<H, B, T>(self, handler: H) -> OnMethod<IntoService<H, B, T>, Self> where
    H: Handler<B, T>, 

Chain an additional handler that will only accept TRACE requests.

See OnMethod::get for an example.

pub fn on<H, B, T>(
    self,
    method: MethodFilter,
    handler: H
) -> OnMethod<IntoService<H, B, T>, Self> where
    H: Handler<B, T>, 

Chain an additional handler that will accept requests matching the given MethodFilter.

Example

use axum::{routing::MethodFilter, prelude::*};

async fn handler() {}

async fn other_handler() {}

// Requests to `GET /` will go to `handler` and `DELETE /` will go to
// `other_handler`
let app = route("/", get(handler).on(MethodFilter::Delete, other_handler));

Trait Implementations

impl<S: Clone, F: Clone> Clone for OnMethod<S, F>

fn clone(&self) -> OnMethod<S, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug, F: Debug> Debug for OnMethod<S, F>

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

Formats the value using the given formatter.

impl<S, F, B> Service<Request<B>> for OnMethod<S, F> where
    S: Service<Request<B>, Response = Response<BoxBody>, Error = Infallible> + Clone,
    F: Service<Request<B>, Response = Response<BoxBody>, Error = Infallible> + Clone, 

type Response = Response<BoxBody>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = RouteFuture<S, F, B>

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Request<B>) -> Self::Future

Process the request and return the response asynchronously.

impl<S: Copy, F: Copy> Copy for OnMethod<S, F>