[][src]Trait actix_web::FromRequest

pub trait FromRequest<S>: Sized {
    type Config: Default;
    type Result: Into<AsyncResult<Self>>;
    fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result;

    fn extract(req: &HttpRequest<S>) -> Self::Result { ... }
}

Trait implemented by types that can be extracted from request.

Types that implement this trait can be used with Route::with() method.

Associated Types

Configuration for conversion process

Future that resolves to a Self

Required Methods

Convert request to a Self

Provided Methods

Convert request to a Self

This method uses default extractor configuration

Implementations on Foreign Types

impl<S: 'static> FromRequest<S> for Bytes
[src]

Request payload extractor.

Loads request's payload and construct Bytes instance.

PayloadConfig allows to configure extraction process.

Example

extern crate bytes;
use actix_web::{http, App, Result};

/// extract text data from request
fn index(body: bytes::Bytes) -> Result<String> {
    Ok(format!("Body {:?}!", body))
}

fn main() {
    let app = App::new()
        .resource("/index.html", |r| r.method(http::Method::GET).with(index));
}

impl<S: 'static> FromRequest<S> for String
[src]

Extract text information from the request's body.

Text extractor automatically decode body according to the request's charset.

PayloadConfig allows to configure extraction process.

Example

use actix_web::{http, App, 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 with extractor params
                  cfg.0.limit(4096);  // <- limit size of the payload
                })
    });
}

impl<T: 'static, S: 'static> FromRequest<S> for Option<T> where
    T: FromRequest<S>, 
[src]

Optionally extract a field from the request

If the FromRequest for T fails, return None rather than returning an error response

Example

extern crate rand;
#[macro_use] extern crate serde_derive;
use actix_web::{http, App, Result, HttpRequest, Error, FromRequest};
use actix_web::error::ErrorBadRequest;

#[derive(Debug, Deserialize)]
struct Thing { name: String }

impl<S> FromRequest<S> for Thing {
    type Config = ();
    type Result = Result<Thing, Error>;

    #[inline]
    fn from_request(req: &HttpRequest<S>, _cfg: &Self::Config) -> Self::Result {
        if rand::random() {
            Ok(Thing { name: "thingy".into() })
        } else {
            Err(ErrorBadRequest("no luck"))
        }

    }
}

/// extract text data from request
fn index(supplied_thing: Option<Thing>) -> Result<String> {
    match supplied_thing {
        // Puns not intended
        Some(thing) => Ok(format!("Got something: {:?}", thing)),
        None => Ok(format!("No thing!"))
    }
}

fn main() {
    let app = App::new().resource("/users/:first", |r| {
        r.method(http::Method::POST).with(index)
    });
}

impl<T: 'static, S: 'static> FromRequest<S> for Result<T, Error> where
    T: FromRequest<S>, 
[src]

Optionally extract a field from the request or extract the Error if unsuccessful

If the FromRequest for T fails, inject Err into handler rather than returning an error response

Example

extern crate rand;
#[macro_use] extern crate serde_derive;
use actix_web::{http, App, Result, HttpRequest, Error, FromRequest};
use actix_web::error::ErrorBadRequest;

#[derive(Debug, Deserialize)]
struct Thing { name: String }

impl<S> FromRequest<S> for Thing {
    type Config = ();
    type Result = Result<Thing, Error>;

    #[inline]
    fn from_request(req: &HttpRequest<S>, _cfg: &Self::Config) -> Self::Result {
        if rand::random() {
            Ok(Thing { name: "thingy".into() })
        } else {
            Err(ErrorBadRequest("no luck"))
        }

    }
}

/// extract text data from request
fn index(supplied_thing: Result<Thing>) -> Result<String> {
    match supplied_thing {
        Ok(thing) => Ok(format!("Got thing: {:?}", thing)),
        Err(e) => Ok(format!("Error extracting thing: {}", e))
    }
}

fn main() {
    let app = App::new().resource("/users/:first", |r| {
        r.method(http::Method::POST).with(index)
    });
}

impl<S> FromRequest<S> for ()
[src]

impl<S, A: FromRequest<S> + 'static> FromRequest<S> for (A,) where
    S: 'static, 
[src]

FromRequest implementation for tuple

impl<S, A: FromRequest<S> + 'static, B: FromRequest<S> + 'static> FromRequest<S> for (A, B) where
    S: 'static, 
[src]

FromRequest implementation for tuple

impl<S, A: FromRequest<S> + 'static, B: FromRequest<S> + 'static, C: FromRequest<S> + 'static> FromRequest<S> for (A, B, C) where
    S: 'static, 
[src]

FromRequest implementation for tuple

impl<S, A: FromRequest<S> + 'static, B: FromRequest<S> + 'static, C: FromRequest<S> + 'static, D: FromRequest<S> + 'static> FromRequest<S> for (A, B, C, D) where
    S: 'static, 
[src]

FromRequest implementation for tuple

impl<S, A: FromRequest<S> + 'static, B: FromRequest<S> + 'static, C: FromRequest<S> + 'static, D: FromRequest<S> + 'static, E: FromRequest<S> + 'static> FromRequest<S> for (A, B, C, D, E) where
    S: 'static, 
[src]

FromRequest implementation for tuple

impl<S, A: FromRequest<S> + 'static, B: FromRequest<S> + 'static, C: FromRequest<S> + 'static, D: FromRequest<S> + 'static, E: FromRequest<S> + 'static, F: FromRequest<S> + 'static> FromRequest<S> for (A, B, C, D, E, F) where
    S: 'static, 
[src]

FromRequest implementation for tuple

impl<S, A: FromRequest<S> + 'static, B: FromRequest<S> + 'static, C: FromRequest<S> + 'static, D: FromRequest<S> + 'static, E: FromRequest<S> + 'static, F: FromRequest<S> + 'static, G: FromRequest<S> + 'static> FromRequest<S> for (A, B, C, D, E, F, G) where
    S: 'static, 
[src]

FromRequest implementation for tuple

impl<S, A: FromRequest<S> + 'static, B: FromRequest<S> + 'static, C: FromRequest<S> + 'static, D: FromRequest<S> + 'static, E: FromRequest<S> + 'static, F: FromRequest<S> + 'static, G: FromRequest<S> + 'static, H: FromRequest<S> + 'static> FromRequest<S> for (A, B, C, D, E, F, G, H) where
    S: 'static, 
[src]

FromRequest implementation for tuple

impl<S, A: FromRequest<S> + 'static, B: FromRequest<S> + 'static, C: FromRequest<S> + 'static, D: FromRequest<S> + 'static, E: FromRequest<S> + 'static, F: FromRequest<S> + 'static, G: FromRequest<S> + 'static, H: FromRequest<S> + 'static, I: FromRequest<S> + 'static> FromRequest<S> for (A, B, C, D, E, F, G, H, I) where
    S: 'static, 
[src]

FromRequest implementation for tuple

Implementors

impl<A: 'static, B: 'static, S: 'static> FromRequest<S> for Either<A, B> where
    A: FromRequest<S>,
    B: FromRequest<S>, 
[src]

Extract either one of two fields from the request.

If both or none of the fields can be extracted, the default behaviour is to prefer the first successful, last that failed. The behaviour can be changed by setting the appropriate EitherCollisionStrategy.

CAVEAT: Most of the time both extractors will be run. Make sure that the extractors you specify can be run one after another (or in parallel). This will always fail for extractors that modify the request state (such as the Form extractors that read in the body stream). So Either<Form, Form> will not work correctly - it will only succeed if it matches the first option, but will always fail to match the second (since the body stream will be at the end, and appear to be empty).

Example

extern crate rand;
#[macro_use] extern crate serde_derive;
use actix_web::{http, App, Result, HttpRequest, Error, FromRequest};
use actix_web::error::ErrorBadRequest;
use actix_web::Either;

#[derive(Debug, Deserialize)]
struct Thing { name: String }

#[derive(Debug, Deserialize)]
struct OtherThing { id: String }

impl<S> FromRequest<S> for Thing {
    type Config = ();
    type Result = Result<Thing, Error>;

    #[inline]
    fn from_request(req: &HttpRequest<S>, _cfg: &Self::Config) -> Self::Result {
        if rand::random() {
            Ok(Thing { name: "thingy".into() })
        } else {
            Err(ErrorBadRequest("no luck"))
        }
    }
}

impl<S> FromRequest<S> for OtherThing {
    type Config = ();
    type Result = Result<OtherThing, Error>;

    #[inline]
    fn from_request(req: &HttpRequest<S>, _cfg: &Self::Config) -> Self::Result {
        if rand::random() {
            Ok(OtherThing { id: "otherthingy".into() })
        } else {
            Err(ErrorBadRequest("no luck"))
        }
    }
}

/// extract text data from request
fn index(supplied_thing: Either<Thing, OtherThing>) -> Result<String> {
    match supplied_thing {
        Either::A(thing) => Ok(format!("Got something: {:?}", thing)),
        Either::B(other_thing) => Ok(format!("Got anotherthing: {:?}", other_thing))
    }
}

fn main() {
    let app = App::new().resource("/users/:first", |r| {
        r.method(http::Method::POST).with(index)
    });
}

impl<S> FromRequest<S> for Session
[src]

Extractor implementation for Session type.

use actix_web::middleware::session::Session;

fn index(session: Session) -> Result<&'static str> {
    // access session data
    if let Some(count) = session.get::<i32>("counter")? {
        session.set("counter", count + 1)?;
    } else {
        session.set("counter", 1)?;
    }

    Ok("Welcome!")
}

impl<S> FromRequest<S> for HttpRequest<S>
[src]

impl<S> FromRequest<S> for State<S>
[src]

impl<T, S> FromRequest<S> for Form<T> where
    T: DeserializeOwned + 'static,
    S: 'static, 
[src]

impl<T, S> FromRequest<S> for Json<T> where
    T: DeserializeOwned + 'static,
    S: 'static, 
[src]

impl<T, S> FromRequest<S> for Path<T> where
    T: DeserializeOwned
[src]

impl<T, S> FromRequest<S> for Query<T> where
    T: DeserializeOwned
[src]