# 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 R

### 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`

[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]

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]

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,`

[src]

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),`

[src]

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,`

[src]

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),`

[src]

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>`

[src]

####

`fn default() -> Route<S>`

[src]

Returns the "default value" for a type. Read more

## Auto Trait Implementations

###

`impl<S> !Send for Route<S>`

###

`impl<S> !Sync for Route<S>`

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)