pub struct Route<S> { /* private fields */ }
Expand description
Resource route definition
Route uses builder-like pattern for configuration. If handler is not explicitly set, default 404 Not Found handler is used.
Implementations
sourceimpl<S: 'static> Route<S>
impl<S: 'static> Route<S>
sourcepub fn filter<T: Predicate<S> + 'static>(&mut self, p: T) -> &mut Self
pub fn filter<T: Predicate<S> + 'static>(&mut self, p: T) -> &mut Self
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())
})
sourcepub fn h<H: Handler<S>>(&mut self, handler: H)
pub fn h<H: Handler<S>>(&mut self, handler: H)
Set handler object. Usually call to this method is last call during route configuration, so it does not return reference to self.
sourcepub fn f<F, R>(&mut self, handler: F)where
F: Fn(&HttpRequest<S>) -> R + 'static,
R: Responder + 'static,
pub fn f<F, R>(&mut self, handler: F)where
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.
sourcepub 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,
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,
Set async handler function.
sourcepub fn with<T, F, R>(&mut self, handler: F)where
F: WithFactory<T, S, R> + 'static,
R: Responder + 'static,
T: FromRequest<S> + 'static,
pub fn with<T, F, R>(&mut self, handler: F)where
F: WithFactory<T, S, 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::{http, App, Path, Result};
#[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 multiple extractors for one handler function.
#[macro_use] extern crate serde_derive;
use actix_web::{http, App, Json, Path, Query, Result};
#[derive(Deserialize)]
struct Info {
username: String,
}
/// extract path info using serde
fn index(
path: Path<Info>, query: Query<HashMap<String, String>>, body: Json<Info>,
) -> Result<String> {
Ok(format!("Welcome {}!", path.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
}
sourcepub fn with_config<T, F, R, C>(&mut self, handler: F, cfg_f: C)where
F: WithFactory<T, S, R>,
R: Responder + 'static,
T: FromRequest<S> + 'static,
C: FnOnce(&mut T::Config),
pub fn with_config<T, F, R, C>(&mut self, handler: F, cfg_f: C)where
F: WithFactory<T, S, R>,
R: Responder + 'static,
T: FromRequest<S> + 'static,
C: FnOnce(&mut T::Config),
Set handler function. Same as .with()
but it allows to configure
extractor. Configuration closure accepts config objects as tuple.
#[macro_use] extern crate serde_derive;
use actix_web::{http, App, Path, Result};
/// extract text data from request
fn index(body: String) -> Result<String> {
Ok(format!("Body {}!", body))
}
fn main() {
let app = App::new().resource("/index.html", |r| {
r.method(http::Method::GET)
.with_config(index, |cfg| { // <- register handler
cfg.0.limit(4096); // <- limit size of the payload
})
});
}
sourcepub fn with_async<T, F, R, I, E>(&mut self, handler: F)where
F: WithAsyncFactory<T, S, R, I, E>,
R: Future<Item = I, Error = E> + 'static,
I: Responder + 'static,
E: Into<Error> + 'static,
T: FromRequest<S> + 'static,
pub fn with_async<T, F, R, I, E>(&mut self, handler: F)where
F: WithAsyncFactory<T, S, R, I, E>,
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::{http, App, Error, Path};
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
}
sourcepub fn with_async_config<T, F, R, I, E, C>(&mut self, handler: F, cfg: C)where
F: WithAsyncFactory<T, S, R, I, E>,
R: Future<Item = I, Error = E> + 'static,
I: Responder + 'static,
E: Into<Error> + 'static,
T: FromRequest<S> + 'static,
C: FnOnce(&mut T::Config),
pub fn with_async_config<T, F, R, I, E, C>(&mut self, handler: F, cfg: C)where
F: WithAsyncFactory<T, S, R, I, E>,
R: Future<Item = I, Error = E> + 'static,
I: Responder + 'static,
E: Into<Error> + 'static,
T: FromRequest<S> + 'static,
C: FnOnce(&mut T::Config),
Set async handler function, use request extractor for parameters. This method allows to configure extractor. Configuration closure accepts config objects as tuple.
#[macro_use] extern crate serde_derive;
use actix_web::{http, App, Error, Form};
use futures::Future;
#[derive(Deserialize)]
struct Info {
username: String,
}
/// extract path info using serde
fn index(info: Form<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_config(index, |cfg| {
cfg.0.limit(4096);
}),
); // <- use `with` extractor
}