Trait routerify::ext::RequestExt[−][src]

pub trait RequestExt {
    fn params(&self) -> &RouteParams;

    fn param<P: Into<String>>(&self, param_name: P) -> Option<&String>;

    fn remote_addr(&self) -> SocketAddr;

    fn data<T: Send + Sync + 'static>(&self) -> Option<&T>;

    fn context<T: Send + Sync + Clone + 'static>(&self) -> Option<T>;

    fn set_context<T: Send + Sync + Clone + 'static>(&self, val: T);
}

A extension trait which extends the hyper::Request and http::Parts types with some helpful methods.

Required methods

fn params(&self) -> &RouteParams[src]

It returns the route parameters as RouteParams type with the name of the parameter specified in the path as their respective keys.

Examples

use routerify::{Router, RouteParams};
use routerify::ext::RequestExt;
use hyper::{Response, Body};

let router = Router::builder()
    .get("/users/:userName/books/:bookName", |req| async move {
        let params: &RouteParams = req.params();
        let user_name = params.get("userName").unwrap();
        let book_name = params.get("bookName").unwrap();

        Ok(Response::new(Body::from(format!("Username: {}, Book Name: {}", user_name, book_name))))
     })
     .build()
     .unwrap();

fn param<P: Into<String>>(&self, param_name: P) -> Option<&String>[src]

It returns the route parameter value by the name of the parameter specified in the path.

Examples

use routerify::{Router, RouteParams};
use routerify::ext::RequestExt;
use hyper::{Response, Body};

let router = Router::builder()
    .get("/users/:userName/books/:bookName", |req| async move {
        let user_name = req.param("userName").unwrap();
        let book_name = req.param("bookName").unwrap();

        Ok(Response::new(Body::from(format!("Username: {}, Book Name: {}", user_name, book_name))))
     })
     .build()
     .unwrap();

fn remote_addr(&self) -> SocketAddr[src]

It returns the remote address of the incoming request.

Examples

use routerify::{Router, RouteParams};
use routerify::ext::RequestExt;
use hyper::{Response, Body};

let router = Router::builder()
    .get("/hello", |req| async move {
        let remote_addr = req.remote_addr();

        Ok(Response::new(Body::from(format!("Hello from : {}", remote_addr))))
     })
     .build()
     .unwrap();

fn data<T: Send + Sync + 'static>(&self) -> Option<&T>[src]

Access data which was shared by the RouterBuilder method data.

Please refer to the Data and State Sharing for more info.

fn context<T: Send + Sync + Clone + 'static>(&self) -> Option<T>[src]

Access data in the request context.

fn set_context<T: Send + Sync + Clone + 'static>(&self, val: T)[src]

Put data into the request context.

Examples

use routerify::{Router, RouteParams, Middleware};
use routerify::ext::RequestExt;
use hyper::{Response, Request, Body};

let router = Router::builder()
    .middleware(Middleware::pre(|req: Request<Body>| async move {
        req.set_context("example".to_string());

        Ok(req)
    }))
    .get("/hello", |req| async move {
        let text = req.context::<String>().unwrap();

        Ok(Response::new(Body::from(format!("Hello from : {}", text))))
     })
     .build()
     .unwrap();
Loading content...

Implementations on Foreign Types

impl RequestExt for Request<Body>[src]

impl RequestExt for Parts[src]

Loading content...

Implementors

Loading content...