Struct Router 

pub struct Router { /* private fields */ }

A modular router for grouping and mounting routes under a common base path.

The Router struct allows you to organize related routes together and mount them onto an application at a specified base path. This is useful for building APIs with versioning, grouping endpoints, or composing applications from multiple routers.

Example

use ripress::{router::Router, app::App};
use ripress::{req::HttpRequest, res::HttpResponse};
use ripress::types::RouterFns;

async fn handler(req: HttpRequest, res: HttpResponse) -> HttpResponse {
    res.ok().text("Hello, World!")
}

let mut router = Router::new("/api");
router.get("/hello", handler);
let mut app = App::new();
app.router(router);

Implementations

impl Router

pub fn new(base_path: &'static str) -> Self

Creates a new Router instance with the specified base path.

The base path determines the prefix under which all routes registered to this router will be mounted when attached to an application.

Arguments

• base_path - The base path (e.g., “/api” or “/v1”) for this router.

Returns

A new Router with an empty set of routes, ready for route registration.

Example

use ripress::router::Router;
let router = Router::new("/api");

pub fn register(self, app: &mut App)

👎Deprecated since 1.9.12:

use app.router instead

Registers a router with an app.

Arguments

• mut app - The instance of the app to register the router too

Example

use ripress::{router::Router, app::App};
use ripress::{req::HttpRequest, res::HttpResponse};
use ripress::types::RouterFns;

async fn handler(req: HttpRequest, res: HttpResponse) -> HttpResponse {
    res.ok().text("Hello, World!")
}

let mut router = Router::new("/api");
let mut app = App::new();
router.patch("/hello", handler);
app.router(router);

Trait Implementations

impl RouterFns for Router

fn routes( &mut self, ) -> &mut HashMap<String, HashMap<HttpMethods, Arc<dyn Fn(HttpRequest, HttpResponse) -> Pin<Box<dyn Future<Output = HttpResponse> + Send + 'static>> + Send + Sync + 'static>>>

Get a mutable reference to the internal routes map.

fn add_route<F, HFut>(&mut self, method: HttpMethods, path: &str, handler: F)

where F: Fn(HttpRequest, HttpResponse) -> HFut + Send + Sync + 'static, HFut: Future<Output = HttpResponse> + Send + 'static,

Register a handler for a specific HTTP method/path.

fn get<F, HFut, P>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(P, HttpResponse) -> HFut + Send + Sync + 'static, HFut: Future<Output = HttpResponse> + Send + 'static, P: ExtractFromOwned + Send + 'static,

Register a GET handler for a path, with extractor integration.

fn options<F, HFut, P>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(P, HttpResponse) -> HFut + Send + Sync + 'static, HFut: Future<Output = HttpResponse> + Send + 'static, P: ExtractFromOwned + Send + 'static,

Register an OPTIONS handler for a path, with extractor integration.

fn post<F, HFut, P>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(P, HttpResponse) -> HFut + Send + Sync + 'static, HFut: Future<Output = HttpResponse> + Send + 'static, P: ExtractFromOwned + Send + 'static,

Register a POST handler for a path, with extractor integration.

fn put<F, HFut, P>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(P, HttpResponse) -> HFut + Send + Sync + 'static, HFut: Future<Output = HttpResponse> + Send + 'static, P: ExtractFromOwned + Send + 'static,

Register a PUT handler for a path, with extractor integration.

fn delete<F, HFut, P>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(P, HttpResponse) -> HFut + Send + Sync + 'static, HFut: Future<Output = HttpResponse> + Send + 'static, P: ExtractFromOwned + Send + 'static,

Register a DELETE handler for a path, with extractor integration.

fn head<F, HFut, P>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(P, HttpResponse) -> HFut + Send + Sync + 'static, HFut: Future<Output = HttpResponse> + Send + 'static, P: ExtractFromOwned + Send + 'static,

Register a HEAD handler for a path, with extractor integration.

fn patch<F, HFut, P>(&mut self, path: &str, handler: F) -> &mut Self

where F: Fn(P, HttpResponse) -> HFut + Send + Sync + 'static, HFut: Future<Output = HttpResponse> + Send + 'static, P: ExtractFromOwned + Send + 'static,

Register a PATCH handler for a path, with extractor integration.

fn get_routes( &mut self, path: &str, method: HttpMethods, ) -> Option<&Arc<dyn Fn(HttpRequest, HttpResponse) -> Pin<Box<dyn Future<Output = HttpResponse> + Send + 'static>> + Send + Sync + 'static>>

Retrieve the route handler for a given path/method, if one is registered.

fn add_route_with_extraction<F, HFut, P>( &mut self, method: HttpMethods, path: &str, handler: F, )

where F: Fn(P, HttpResponse) -> HFut + Send + Sync + 'static, HFut: Future<Output = HttpResponse> + Send + 'static, P: ExtractFromOwned + Send + 'static,

Internal helper: Register a handler using extractor integration.