Struct actix_web::dev::Route
[−]
[src]
pub struct Route<S> { /* fields omitted */ }
Resource route definition
Route uses builder-like pattern for configuration. If handler is not explicitly set, default 404 Not Found handler is used.
Methods
impl<S: 'static> Route<S>
[src]
ⓘImportant traits for &'a mut Wpub fn filter<T: Predicate<S> + 'static>(&mut self, p: T) -> &mut Self
[src]
Add match predicate to route.
App::new() .resource("/path", |r| r.route() .filter(pred::Get()) .filter(pred::Header("content-type", "text/plain")) .f(|req| HttpResponse::Ok()) )
pub fn h<H: Handler<S>>(&mut self, handler: H)
[src]
Set handler object. Usually call to this method is last call during route configuration, so it does not return reference to self.
pub fn f<F, R>(&mut self, handler: F) where
F: Fn(HttpRequest<S>) -> R + 'static,
R: Responder + 'static,
[src]
F: Fn(HttpRequest<S>) -> R + 'static,
R: Responder + 'static,
Set handler function. Usually call to this method is last call during route configuration, so it does not return reference to self.
pub fn a<H, R, F, E>(&mut self, handler: H) where
H: Fn(HttpRequest<S>) -> F + 'static,
F: Future<Item = R, Error = E> + 'static,
R: Responder + 'static,
E: Into<Error> + 'static,
[src]
H: Fn(HttpRequest<S>) -> F + 'static,
F: Future<Item = R, Error = E> + 'static,
R: Responder + 'static,
E: Into<Error> + 'static,
Set async handler function.
pub fn with<T, F, R>(&mut self, handler: F) -> ExtractorConfig<S, T> where
F: Fn(T) -> R + 'static,
R: Responder + 'static,
T: FromRequest<S> + 'static,
[src]
F: Fn(T) -> R + 'static,
R: Responder + 'static,
T: FromRequest<S> + 'static,
Set handler function, use request extractor for parameters.
#[macro_use] extern crate serde_derive; use actix_web::{App, Path, Result, http}; #[derive(Deserialize)] struct Info { username: String, } /// extract path info using serde fn index(info: Path<Info>) -> Result<String> { Ok(format!("Welcome {}!", info.username)) } fn main() { let app = App::new().resource( "/{username}/index.html", // <- define path parameters |r| r.method(http::Method::GET).with(index)); // <- use `with` extractor }
It is possible to use tuples for specifing multiple extractors for one handler function.
#[macro_use] extern crate serde_derive; use actix_web::{http, App, Query, Path, Result, Json}; #[derive(Deserialize)] struct Info { username: String, } /// extract path info using serde fn index(info: (Path<Info>, Query<HashMap<String, String>>, Json<Info>)) -> Result<String> { Ok(format!("Welcome {}!", info.0.username)) } fn main() { let app = App::new().resource( "/{username}/index.html", // <- define path parameters |r| r.method(http::Method::GET).with(index)); // <- use `with` extractor }
pub fn with_async<T, F, R, I, E>(&mut self, handler: F) -> ExtractorConfig<S, T> where
F: Fn(T) -> R + 'static,
R: Future<Item = I, Error = E> + 'static,
I: Responder + 'static,
E: Into<Error> + 'static,
T: FromRequest<S> + 'static,
[src]
F: Fn(T) -> R + 'static,
R: Future<Item = I, Error = E> + 'static,
I: Responder + 'static,
E: Into<Error> + 'static,
T: FromRequest<S> + 'static,
Set async handler function, use request extractor for parameters.
Also this method needs to be used if your handler function returns
impl Future<>
#[macro_use] extern crate serde_derive; use actix_web::{App, Path, Error, http}; use futures::Future; #[derive(Deserialize)] struct Info { username: String, } /// extract path info using serde fn index(info: Path<Info>) -> Box<Future<Item=&'static str, Error=Error>> { unimplemented!() } fn main() { let app = App::new().resource( "/{username}/index.html", // <- define path parameters |r| r.method(http::Method::GET) .with_async(index)); // <- use `with` extractor }