Struct MethodRouter 

pub struct MethodRouter<B = Body, E = Infallible> { /* private fields */ }

Available on crate feature server only.

A method router that handle the request and dispatch it by its method.

There is no need to create MethodRouter directly, you can use specific method for creating it. What’s more, the method router allows chaining additional handlers or services.

Examples

use std::convert::Infallible;

use volo::service::service_fn;
use volo_http::{
    context::ServerContext,
    request::Request,
    server::route::{MethodRouter, Router, any, get, post_service},
};

async fn index() -> &'static str {
    "Hello, World"
}

async fn index_fn(cx: &mut ServerContext, req: Request) -> Result<&'static str, Infallible> {
    Ok("Hello, World")
}

let _: MethodRouter = get(index);
let _: MethodRouter = any(index);
let _: MethodRouter = post_service(service_fn(index_fn));

let _: MethodRouter = get(index).post(index).options_service(service_fn(index_fn));

let app: Router = Router::new().route("/", get(index));
let app: Router = Router::new().route("/", get(index).post(index).head(index));

Implementations

impl<B, E> MethodRouter<B, E>

where B: Send + 'static, E: 'static,

pub fn layer<L, B2, E2>(self, l: L) -> MethodRouter<B2, E2>

where L: Layer<Route<B, E>> + Clone + Send + Sync + 'static, L::Service: Service<ServerContext, Request<B2>, Error = E2> + Send + Sync + 'static, <L::Service as Service<ServerContext, Request<B2>>>::Response: IntoResponse, B2: 'static,

Add a new inner layer to all routes in this method router.

The layer’s Service should be Clone + Send + Sync + 'static.

impl<B, E> MethodRouter<B, E>

where B: Send + 'static, E: IntoResponse + 'static,

pub fn options<H, T>(self, handler: H) -> Self

where for<'a> H: Handler<T, B, E> + Clone + Send + Sync + 'a, B: Send, T: 'static,

Route options requests to the given handler.

pub fn options_service<S>(self, service: S) -> MethodRouter<B, E>

where for<'a> S: Service<ServerContext, Request<B>, Error = E> + Send + Sync + 'a, S::Response: IntoResponse,

Route options requests to the given service.

pub fn get<H, T>(self, handler: H) -> Self

where for<'a> H: Handler<T, B, E> + Clone + Send + Sync + 'a, B: Send, T: 'static,

Route get requests to the given handler.

pub fn get_service<S>(self, service: S) -> MethodRouter<B, E>

where for<'a> S: Service<ServerContext, Request<B>, Error = E> + Send + Sync + 'a, S::Response: IntoResponse,

Route get requests to the given service.

pub fn post<H, T>(self, handler: H) -> Self

where for<'a> H: Handler<T, B, E> + Clone + Send + Sync + 'a, B: Send, T: 'static,

Route post requests to the given handler.

pub fn post_service<S>(self, service: S) -> MethodRouter<B, E>

where for<'a> S: Service<ServerContext, Request<B>, Error = E> + Send + Sync + 'a, S::Response: IntoResponse,

Route post requests to the given service.

pub fn put<H, T>(self, handler: H) -> Self

where for<'a> H: Handler<T, B, E> + Clone + Send + Sync + 'a, B: Send, T: 'static,

Route put requests to the given handler.

pub fn put_service<S>(self, service: S) -> MethodRouter<B, E>

where for<'a> S: Service<ServerContext, Request<B>, Error = E> + Send + Sync + 'a, S::Response: IntoResponse,

Route put requests to the given service.

pub fn delete<H, T>(self, handler: H) -> Self

where for<'a> H: Handler<T, B, E> + Clone + Send + Sync + 'a, B: Send, T: 'static,

Route delete requests to the given handler.

pub fn delete_service<S>(self, service: S) -> MethodRouter<B, E>

where for<'a> S: Service<ServerContext, Request<B>, Error = E> + Send + Sync + 'a, S::Response: IntoResponse,

Route delete requests to the given service.

pub fn head<H, T>(self, handler: H) -> Self

where for<'a> H: Handler<T, B, E> + Clone + Send + Sync + 'a, B: Send, T: 'static,

Route head requests to the given handler.

pub fn head_service<S>(self, service: S) -> MethodRouter<B, E>

where for<'a> S: Service<ServerContext, Request<B>, Error = E> + Send + Sync + 'a, S::Response: IntoResponse,

Route head requests to the given service.

pub fn trace<H, T>(self, handler: H) -> Self

where for<'a> H: Handler<T, B, E> + Clone + Send + Sync + 'a, B: Send, T: 'static,

Route trace requests to the given handler.

pub fn trace_service<S>(self, service: S) -> MethodRouter<B, E>

where for<'a> S: Service<ServerContext, Request<B>, Error = E> + Send + Sync + 'a, S::Response: IntoResponse,

Route trace requests to the given service.

pub fn connect<H, T>(self, handler: H) -> Self

where for<'a> H: Handler<T, B, E> + Clone + Send + Sync + 'a, B: Send, T: 'static,

Route connect requests to the given handler.

pub fn connect_service<S>(self, service: S) -> MethodRouter<B, E>

where for<'a> S: Service<ServerContext, Request<B>, Error = E> + Send + Sync + 'a, S::Response: IntoResponse,

Route connect requests to the given service.

pub fn patch<H, T>(self, handler: H) -> Self

where for<'a> H: Handler<T, B, E> + Clone + Send + Sync + 'a, B: Send, T: 'static,

Route patch requests to the given handler.

pub fn patch_service<S>(self, service: S) -> MethodRouter<B, E>

where for<'a> S: Service<ServerContext, Request<B>, Error = E> + Send + Sync + 'a, S::Response: IntoResponse,

Route patch requests to the given service.

pub fn fallback<H, T>(self, handler: H) -> Self

where for<'a> H: Handler<T, B, E> + Clone + Send + Sync + 'a, T: 'static,

Set a fallback handler for the route.

If there is no method that the route can handle, method router will call the fallback handler.

Default is returning “405 Method Not Allowed”.

pub fn fallback_service<S>(self, service: S) -> Self

where for<'a> S: Service<ServerContext, Request<B>, Error = E> + Send + Sync + 'a, S::Response: IntoResponse,

Set a fallback service for the route.

If there is no method that the route can handle, method router will call the fallback service.

Default is returning “405 Method Not Allowed”.

Trait Implementations

impl<B, E> Default for MethodRouter<B, E>

where B: Send + 'static, E: 'static,

fn default() -> Self

Returns the “default value” for a type.

impl<B, E> Service<ServerContext, Request<B>> for MethodRouter<B, E>

where B: Send,

type Response = Response<Body>

Responses given by the service.

type Error = E

Errors produced by the service.

async fn call( &self, cx: &mut ServerContext, req: Request<B>, ) -> Result<Self::Response, Self::Error>

Available on crate feature service_send only.

Process the request and return the response asynchronously.