Struct Router 

pub struct Router { /* private fields */ }

Implementations

impl Router

pub fn new() -> Self

pub fn with_host(self, host: &str) -> Self

Restrict this router to requests for host: their Host header (:authority over HTTP/2 and HTTP/3), else the TLS SNI name, ignoring case and a port host doesn’t name. Call before registering routes.

pub fn get<F>(self, pattern: &str, handler: F) -> Self

where F: Fn(&Request, &PathParams, &ConnectionInfo) -> Response + Send + Sync + 'static,

Register a GET handler for pattern.

pub fn websocket<F>(self, pattern: &str, handler: F) -> Self

where F: Fn(WebSocketConnection, PathParams) + Send + Sync + 'static,

Available on non-WebAssembly only.

Serve WebSocket connections at pattern: an upgrade request’s connection goes to handler with the route’s parameters, anything else gets 426 Upgrade Required (see WebSocket::upgrade).

use rust_web_server::router::Router;
use rust_web_server::websocket::Message;

let router = Router::new().websocket("/rooms/:room", |mut ws, params| {
    let room = params.get("room").unwrap_or("lobby").to_string();
    while let Ok(Some(Message::Text(text))) = ws.recv() {
        let _ = ws.send_text(&format!("{room}: {text}"));
    }
});

pub fn post<F>(self, pattern: &str, handler: F) -> Self

where F: Fn(&Request, &PathParams, &ConnectionInfo) -> Response + Send + Sync + 'static,

Register a POST handler for pattern.

pub fn put<F>(self, pattern: &str, handler: F) -> Self

where F: Fn(&Request, &PathParams, &ConnectionInfo) -> Response + Send + Sync + 'static,

Register a PUT handler for pattern.

pub fn patch<F>(self, pattern: &str, handler: F) -> Self

where F: Fn(&Request, &PathParams, &ConnectionInfo) -> Response + Send + Sync + 'static,

Register a PATCH handler for pattern.

pub fn delete<F>(self, pattern: &str, handler: F) -> Self

where F: Fn(&Request, &PathParams, &ConnectionInfo) -> Response + Send + Sync + 'static,

Register a DELETE handler for pattern.

pub fn route<H: Handler<()>>(self, handler: H) -> Self

Register a typed handler (18.28.0): a function with extractor arguments annotated #[get("/path")] & co., whose method and pattern come from the attribute. A router has no state, so State<S> and &S arguments aren’t available here — use AppWithState::route.

#[get("/users/{id}")]
fn user(Path(id): Path<u64>) -> String { format!("user {id}") }

let router = Router::new().route(user);

pub fn route_conflicts(&self) -> Vec<RouteConflict>

Routes that never run (18.28.0): registered after a route with the same method whose pattern is equivalent (/users/:id and /users/{uid}) or matches every path they do (/users/:id before /users/me). Routes are tried in order, so the earlier one always wins. Each is also printed once to stderr when it is registered.

pub fn route_entries(&self) -> Vec<RouteInfo>

Return a snapshot of all registered routes as (method, pattern) pairs.

Patterns are reconstructed from parsed segments, so the output exactly matches what was passed to .get(), .post(), etc. at registration time.

pub fn handle( &self, request: &Request, connection: &ConnectionInfo, ) -> Option<Response>

Try to match request against registered routes in registration order.

Returns Some(response) on the first match, None if no route matches. The query string is stripped before matching; only the path is used.

When .with_host() is set, this returns None immediately unless the request’s host (Host header, else SNI) matches.

pub fn matches(&self, request: &Request, connection: &ConnectionInfo) -> bool

true if handle would run a handler for request (method, path and host all match), without running it.

Trait Implementations

impl Clone for Router

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.