Struct worker::Router

pub struct Router<'a, D> { /* private fields */ }

A path-based HTTP router supporting exact-match or wildcard placeholders and shared data.

Implementations

impl<'a> Router<'a, ()>

pub fn new() -> Self

Construct a new Router. Or, call Router::with_data(D) to add arbitrary data that will be available to your various routes.

impl<'a, D: 'a> Router<'a, D>

pub fn with_data(data: D) -> Self

Construct a new Router with arbitrary data that will be available to your various routes.

pub fn head(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> Result<Response>
) -> Self

Register an HTTP handler that will exclusively respond to HEAD requests.

pub fn get(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> Result<Response>
) -> Self

Register an HTTP handler that will exclusively respond to GET requests.

pub fn post(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> Result<Response>
) -> Self

Register an HTTP handler that will exclusively respond to POST requests.

pub fn put(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> Result<Response>
) -> Self

Register an HTTP handler that will exclusively respond to PUT requests.

pub fn patch(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> Result<Response>
) -> Self

Register an HTTP handler that will exclusively respond to PATCH requests.

pub fn delete(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> Result<Response>
) -> Self

Register an HTTP handler that will exclusively respond to DELETE requests.

pub fn options(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> Result<Response>
) -> Self

Register an HTTP handler that will exclusively respond to OPTIONS requests.

pub fn on(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> Result<Response>
) -> Self

Register an HTTP handler that will respond to any requests.

pub fn or_else_any_method(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> Result<Response>
) -> Self

Register an HTTP handler that will respond to all methods that are not handled explicitly by other handlers.

pub fn head_async<T>(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> T
) -> Self where
    T: Future<Output = Result<Response>> + 'a, 

Register an HTTP handler that will exclusively respond to HEAD requests. Enables the use of async/await syntax in the callback.

pub fn get_async<T>(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> T
) -> Self where
    T: Future<Output = Result<Response>> + 'a, 

Register an HTTP handler that will exclusively respond to GET requests. Enables the use of async/await syntax in the callback.

pub fn post_async<T>(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> T
) -> Self where
    T: Future<Output = Result<Response>> + 'a, 

Register an HTTP handler that will exclusively respond to POST requests. Enables the use of async/await syntax in the callback.

pub fn put_async<T>(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> T
) -> Self where
    T: Future<Output = Result<Response>> + 'a, 

Register an HTTP handler that will exclusively respond to PUT requests. Enables the use of async/await syntax in the callback.

pub fn patch_async<T>(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> T
) -> Self where
    T: Future<Output = Result<Response>> + 'a, 

Register an HTTP handler that will exclusively respond to PATCH requests. Enables the use of async/await syntax in the callback.

pub fn delete_async<T>(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> T
) -> Self where
    T: Future<Output = Result<Response>> + 'a, 

Register an HTTP handler that will exclusively respond to DELETE requests. Enables the use of async/await syntax in the callback.

pub fn options_async<T>(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> T
) -> Self where
    T: Future<Output = Result<Response>> + 'a, 

Register an HTTP handler that will exclusively respond to OPTIONS requests. Enables the use of async/await syntax in the callback.

pub fn on_async<T>(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> T
) -> Self where
    T: Future<Output = Result<Response>> + 'a, 

Register an HTTP handler that will respond to any requests. Enables the use of async/await syntax in the callback.

pub fn or_else_any_method_async<T>(
    self,
    pattern: &str,
    func: fn(_: Request, _: RouteContext<D>) -> T
) -> Self where
    T: Future<Output = Result<Response>> + 'a, 

Register an HTTP handler that will respond to all methods that are not handled explicitly by other handlers. Enables the use of async/await syntax in the callback.

pub async fn run(self, req: Request, env: Env) -> Result<Response>

Handle the request provided to the Router and return a Future.