Struct actix_web::dev::Route

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>

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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())
})

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.

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.

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.

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, 

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 tuples for specifing 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(
    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, 

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
}

Trait Implementations

impl<S: 'static> Default for Route<S>

fn default() -> Route<S>

Returns the "default value" for a type.