# [−][src]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>`

[src]

####

`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: WithFactory<T, S, 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 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
    }

####

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

[src]

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

####

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

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

[src]

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
    }

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

## Blanket Implementations

###

`impl<T> From for T`

[src]

####

`fn from(t: T) -> T`

[src]

Performs the conversion.

###

`impl<T, U> Into for T where U: From<T>,`

[src]

####

`fn into(self) -> U`

[src]

Performs the conversion.

###

`impl<T, U> TryFrom for T where T: From<U>,`

[src]

#### `type Error = !`

🔬 This is a nightly-only experimental API. (`try_from`)

The type returned in the event of a conversion error.

####

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

[src]

🔬 This is a nightly-only experimental API. (`try_from`)

Performs the conversion.

###

`impl<T> Borrow for T where T: ?Sized,`

[src]

####

`fn borrow(&self) -> &T`

[src]

Immutably borrows from an owned value. Read more

###

`impl<T> BorrowMut for T where T: ?Sized,`

[src]

####

`fn borrow_mut(&mut self) -> &mut T`

[src]

Mutably borrows from an owned value. Read more

###

`impl<T, U> TryInto for T where U: TryFrom<T>,`

[src]

#### `type Error = <U as TryFrom<T>>::Error`

🔬 This is a nightly-only experimental API. (`try_from`)

The type returned in the event of a conversion error.

####

`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

[src]

🔬 This is a nightly-only experimental API. (`try_from`)

Performs the conversion.

###

`impl<T> Any for T where T: 'static + ?Sized,`

[src]

####

`fn get_type_id(&self) -> TypeId`

[src]

🔬 This is a nightly-only experimental API. (`get_type_id`)

this method will likely be replaced by an associated static

Gets the `TypeId` of `self`. Read more

###

`impl<T> Erased for T`

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