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::{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, 

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
}

Trait Implementations

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

fn default() -> Route<S>

Returns the "default value" for a type.