Struct Router

pub struct Router { /* private fields */ }

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

Implementations

impl Router

pub fn new() -> Router

Construct a new, empty Router.

use ferrum_router::Router;
let router = Router::new();

Examples found in repository

examples/simple.rs (line 22)

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

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

examples/custom_404.rs (line 28)

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

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

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

examples/struct_handler.rs (line 22)

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

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

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

examples/simple_with_types.rs (line 42)

fn main() {
    let mut types = DefaultStore::with_default_types();
    types.insert("id_type", "[1-9][0-9]*");

    let mut router = Router::new();
    router.get("/", handler, None);
    router.get(("/{id:id_type}", &types), id_handler, None);
    router.get(("/{query:string}", &types), query_handler, None);

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

pub fn route<G, H, S, T>( &mut self, method: Method, glob: G, handler: H, route_id: Option<Id>, ) -> &mut Router

where G: Into<Glob<S, T>>, H: Handler, S: AsRef<[u8]>, T: GlobTypes,

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

route supports glob patterns based on the rust regex and uses {name} ({name: typename}, {name: pattern}) for matching storing named 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:[0-9]+}/{friendid:[0-9]+} and store userid and friend in the exposed Params object:

let mut router = Router::new();
router.route(Method::Get, "/users/{userid:[0-9]+}/{friendid:[0-9]+}", controller, "user_friend");

route_id is a optional unique name for your route, and is used when generating an URI 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<G, H, S, T>( &mut self, glob: G, handler: H, route_id: Option<Id>, ) -> &mut Router

where G: Into<Glob<S, T>>, H: Handler, S: AsRef<[u8]>, T: GlobTypes,

Like route, but specialized to the Get method.

Examples found in repository

examples/simple.rs (line 23)

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

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

examples/custom_404.rs (line 29)

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

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

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

examples/struct_handler.rs (line 23)

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

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

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

examples/simple_with_types.rs (line 43)

fn main() {
    let mut types = DefaultStore::with_default_types();
    types.insert("id_type", "[1-9][0-9]*");

    let mut router = Router::new();
    router.get("/", handler, None);
    router.get(("/{id:id_type}", &types), id_handler, None);
    router.get(("/{query:string}", &types), query_handler, None);

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

pub fn post<G, H, S, T>( &mut self, glob: G, handler: H, route_id: Option<Id>, ) -> &mut Router

where G: Into<Glob<S, T>>, H: Handler, S: AsRef<[u8]>, T: GlobTypes,

Like route, but specialized to the Post method.

pub fn put<G, H, S, T>( &mut self, glob: G, handler: H, route_id: Option<Id>, ) -> &mut Router

where G: Into<Glob<S, T>>, H: Handler, S: AsRef<[u8]>, T: GlobTypes,

Like route, but specialized to the Put method.

pub fn delete<G, H, S, T>( &mut self, glob: G, handler: H, route_id: Option<Id>, ) -> &mut Router

where G: Into<Glob<S, T>>, H: Handler, S: AsRef<[u8]>, T: GlobTypes,

Like route, but specialized to the Delete method.

pub fn head<G, H, S, T>( &mut self, glob: G, handler: H, route_id: Option<Id>, ) -> &mut Router

where G: Into<Glob<S, T>>, H: Handler, S: AsRef<[u8]>, T: GlobTypes,

Like route, but specialized to the Head method.

pub fn patch<G, H, S, T>( &mut self, glob: G, handler: H, route_id: Option<Id>, ) -> &mut Router

where G: Into<Glob<S, T>>, H: Handler, S: AsRef<[u8]>, T: GlobTypes,

Like route, but specialized to the Patch method.

pub fn options<G, H, S, T>( &mut self, glob: G, handler: H, route_id: Option<Id>, ) -> &mut Router

where G: Into<Glob<S, T>>, H: Handler, S: AsRef<[u8]>, T: GlobTypes,

Like route, but specialized to the Options method.

pub fn any<G, H, S, T>( &mut self, glob: G, handler: H, route_id: Option<Id>, ) -> &mut Router

where G: Into<Glob<S, T>>, H: Handler, S: AsRef<[u8]>, T: GlobTypes,

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, request: &mut Request) -> FerrumResult<Response>

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

impl Key for Router

type Value = BTreeMap<String, String>

The value type associated with this key type.