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 R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?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) 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_config<T, F, R, C>(&mut self, handler: F, cfg_f: C) where     F: Fn(T) -> R + 'static,     R: Responder + 'static,     T: FromRequest<S> + 'static,     C: FnOnce(&mut T::Config),

Set handler function. Same as .with() but it allows to configure extractor.

#[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.limit(4096);  // <- limit size of the payload
                })
    });
}

pub fn with_async<T, F, R, I, E>(&mut self, handler: F) 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
}

pub fn with_async_config<T, F, R, I, E, C>(&mut self, handler: F, cfg: C) where     F: Fn(T) -> R + 'static,     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.

#[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.limit(4096);
           }),
    ); // <- use `with` extractor
}

Trait Implementations

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

fn default() -> Route<S>

Returns the "default value" for a type.