Struct Router

pub struct Router { /* private fields */ }

Router provides an interface for creating complex routes as middleware for the Iron framework.

Implementations

impl Router

pub fn new() -> Router

Construct a new, empty Router.

let router = Router::new();

Examples found in repository

examples/custom_404.rs (line 28)

fn main() {
    let mut router = Router::new();
    router.get("/", handler, "example");

    let mut chain = Chain::new(router);
    chain.link_after(Custom404);

    Iron::new(chain).http("localhost:3000").unwrap();
}

examples/struct_handler.rs (line 27)

fn main() {
    let handler = MessageHandler {
        message: "You've found the index page!".to_string()
    };

    let mut router = Router::new();
    router.get("/", handler, "index");

    Iron::new(router).http("localhost:3000").unwrap();
}

examples/simple.rs (line 13)

fn main() {
    let mut router = Router::new();
    router.get("/", handler, "handler");
    router.get("/:query", query_handler, "query_handler");

    Iron::new(router).http("localhost:3000").unwrap();

    fn handler(_: &mut Request) -> IronResult<Response> {
        Ok(Response::with((status::Ok, "OK")))
    }

    fn query_handler(req: &mut Request) -> IronResult<Response> {
        let ref query = req.extensions.get::<Router>()
            .unwrap().find("query").unwrap_or("/");
        Ok(Response::with((status::Ok, *query)))
    }


}

pub fn route<S: AsRef<str>, H: Handler, I: AsRef<str>>( &mut self, method: Method, glob: S, handler: H, route_id: I, ) -> &mut Router

Add a new route to a Router, matching both a method and glob pattern.

route supports glob patterns: * for a single wildcard segment and :param for matching storing that segment of the request url in the Params object, which is stored in the request extensions.

For instance, to route Get requests on any route matching /users/:userid/:friend and store userid and friend in the exposed Params object:

let mut router = Router::new();
router.route(method::Get, "/users/:userid/:friendid", controller, "user_friend");

route_id is a unique name for your route, and is used when generating an URL with url_for.

The controller provided to route can be any Handler, which allows extreme flexibility when handling routes. For instance, you could provide a Chain, a Handler, which contains an authorization middleware and a controller function, so that you can confirm that the request is authorized for this route before handling it.

pub fn get<S: AsRef<str>, H: Handler, I: AsRef<str>>( &mut self, glob: S, handler: H, route_id: I, ) -> &mut Router

Like route, but specialized to the Get method.

Examples found in repository

examples/custom_404.rs (line 29)

fn main() {
    let mut router = Router::new();
    router.get("/", handler, "example");

    let mut chain = Chain::new(router);
    chain.link_after(Custom404);

    Iron::new(chain).http("localhost:3000").unwrap();
}

examples/struct_handler.rs (line 28)

fn main() {
    let handler = MessageHandler {
        message: "You've found the index page!".to_string()
    };

    let mut router = Router::new();
    router.get("/", handler, "index");

    Iron::new(router).http("localhost:3000").unwrap();
}

examples/simple.rs (line 14)

fn main() {
    let mut router = Router::new();
    router.get("/", handler, "handler");
    router.get("/:query", query_handler, "query_handler");

    Iron::new(router).http("localhost:3000").unwrap();

    fn handler(_: &mut Request) -> IronResult<Response> {
        Ok(Response::with((status::Ok, "OK")))
    }

    fn query_handler(req: &mut Request) -> IronResult<Response> {
        let ref query = req.extensions.get::<Router>()
            .unwrap().find("query").unwrap_or("/");
        Ok(Response::with((status::Ok, *query)))
    }


}

pub fn post<S: AsRef<str>, H: Handler, I: AsRef<str>>( &mut self, glob: S, handler: H, route_id: I, ) -> &mut Router

Like route, but specialized to the Post method.

pub fn put<S: AsRef<str>, H: Handler, I: AsRef<str>>( &mut self, glob: S, handler: H, route_id: I, ) -> &mut Router

Like route, but specialized to the Put method.

pub fn delete<S: AsRef<str>, H: Handler, I: AsRef<str>>( &mut self, glob: S, handler: H, route_id: I, ) -> &mut Router

Like route, but specialized to the Delete method.

pub fn head<S: AsRef<str>, H: Handler, I: AsRef<str>>( &mut self, glob: S, handler: H, route_id: I, ) -> &mut Router

Like route, but specialized to the Head method.

pub fn patch<S: AsRef<str>, H: Handler, I: AsRef<str>>( &mut self, glob: S, handler: H, route_id: I, ) -> &mut Router

Like route, but specialized to the Patch method.

pub fn options<S: AsRef<str>, H: Handler, I: AsRef<str>>( &mut self, glob: S, handler: H, route_id: I, ) -> &mut Router

Like route, but specialized to the Options method.

pub fn any<S: AsRef<str>, H: Handler, I: AsRef<str>>( &mut self, glob: S, handler: H, route_id: I, ) -> &mut Router

Route will match any method, including gibberish. In case of ambiguity, handlers specific to methods will be preferred.

Trait Implementations

impl Handler for Router

fn handle(&self, req: &mut Request<'_, '_>) -> IronResult<Response>

Produce a Response from a Request, with the possibility of error.

impl Key for Router

type Value = Params

The value type associated with this key type.