# Struct actix_web::dev::Resource[−][src]

    pub struct Resource<S = ()> { /* fields omitted */ }

Resource is an entry in route table which corresponds to requested URL.

Resource in turn has at least one route. Route consists of an object that implements `Handler` trait (handler) and list of predicates (objects that implement `Predicate` trait). Route uses builder-like pattern for configuration. During request handling, resource object iterate through all routes and check all predicates for specific route, if request matches all predicates route route considered matched and route handler get called.

    use actix_web::{App, HttpResponse, http};

    fn main() {
        let app = App::new()
            .resource(
                "/", |r| r.method(http::Method::GET).f(|r| HttpResponse::Ok()))
            .finish();
    }

## Methods

###

`impl<S> Resource<S>`

[src]

####

`pub fn new(rdef: ResourceDef) -> Self`

[src]

Create new resource with specified resource definition

####

`pub fn name(&mut self, name: &str)`

[src]

Set resource name

####

`pub fn rdef(&self) -> &ResourceDef`

[src]

Resource definition

###

`impl<S: 'static> Resource<S>`

[src]

####

`pub fn route(&mut self) -> &mut Route<S>`

[src]

Register a new route and return mutable reference to Route object. Route is used for route configuration, i.e. adding predicates, setting up handler.

    use actix_web::*;

    fn main() {
        let app = App::new()
            .resource("/", |r| {
                r.route()
                    .filter(pred::Any(pred::Get()).or(pred::Put()))
                    .filter(pred::Header("Content-Type", "text/plain"))
                    .f(|r| HttpResponse::Ok())
            })
            .finish();
    }

####

`pub fn get(&mut self) -> &mut Route<S>`

[src]

Register a new `GET` route.

####

`pub fn post(&mut self) -> &mut Route<S>`

[src]

Register a new `POST` route.

####

`pub fn put(&mut self) -> &mut Route<S>`

[src]

Register a new `PUT` route.

####

`pub fn delete(&mut self) -> &mut Route<S>`

[src]

Register a new `DELETE` route.

####

`pub fn head(&mut self) -> &mut Route<S>`

[src]

Register a new `HEAD` route.

####

`pub fn method(&mut self, method: Method) -> &mut Route<S>`

[src]

Register a new route and add method check to route.

    use actix_web::*;
    fn index(req: &HttpRequest) -> HttpResponse { unimplemented!() }

    App::new().resource("/", |r| r.method(http::Method::GET).f(index));

This is shortcut for:

    App::new().resource("/", |r| r.route().filter(pred::Get()).f(index));

####

`pub fn h<H: Handler<S>>(&mut self, handler: H)`

[src]

Register a new route and add handler object.

    use actix_web::*;
    fn handler(req: &HttpRequest) -> HttpResponse { unimplemented!() }

    App::new().resource("/", |r| r.h(handler));

This is shortcut for:

    App::new().resource("/", |r| r.route().h(handler));

####

`pub fn f<F, R>(&mut self, handler: F) where F: Fn(&HttpRequest<S>) -> R + 'static, R: Responder + 'static,`

[src]

Register a new route and add handler function.

    use actix_web::*;
    fn index(req: &HttpRequest) -> HttpResponse { unimplemented!() }

    App::new().resource("/", |r| r.f(index));

This is shortcut for:

    App::new().resource("/", |r| r.route().f(index));

####

`pub fn with<T, F, R>(&mut self, handler: F) where F: Fn(T) -> R + 'static, R: Responder + 'static, T: FromRequest<S> + 'static,`

[src]

Register a new route and add handler.

    use actix_web::*;
    fn index(req: HttpRequest) -> HttpResponse { unimplemented!() }

    App::new().resource("/", |r| r.with(index));

This is shortcut for:

    App::new().resource("/", |r| r.route().with(index));

####

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

Register a new route and add async handler.

    use actix_web::*;
    use futures::future::Future;

    fn index(req: HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
        unimplemented!()
    }

    App::new().resource("/", |r| r.with_async(index));

This is shortcut for:

    App::new().resource("/", |r| r.route().with_async(index));

####

`pub fn middleware<M: Middleware<S>>(&mut self, mw: M)`

[src]

Register a resource middleware

This is similar to `App's` middlewares, but middlewares get invoked on resource level.

Note `Middleware::finish()` fires right after response get prepared. It does not wait until body get sent to peer.

## Auto Trait Implementations

###

`impl<S = ()> !Send for Resource<S>`

###

`impl<S = ()> !Sync for Resource<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`)