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

type Config: Default

Configuration for conversion process

type Result: Into<AsyncResult<Self>>

Future that resolves to a Self

Loading content...

Required methods

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

Convert request to a Self

Loading content...

Provided methods

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

Convert request to a Self

This method uses default extractor configuration

Loading content...

Implementations on Foreign Types

impl<S: 'static> FromRequest<S> for Bytes

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

type Config = PayloadConfig

type Result = Result<Box<dyn Future<Item = Self, Error = Error>>, Error>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

impl<S: 'static> FromRequest<S> for String

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

type Config = PayloadConfig

type Result = Result<Box<dyn Future<Item = String, Error = Error>>, Error>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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

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

type Config = T::Config

type Result = Box<dyn Future<Item = Option<T>, Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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

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

type Config = T::Config

type Result = Box<dyn Future<Item = Result<T, Error>, Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

impl<S> FromRequest<S> for ()

type Config = ()

type Result = Self

fn from_request(_req: &HttpRequest<S>, _cfg: &Self::Config) -> Self::Result

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

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

FromRequest implementation for tuple

type Config = (A::Config,)

type Result = Box<dyn Future<Item = (A,), Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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

FromRequest implementation for tuple

type Config = (A::Config, B::Config)

type Result = Box<dyn Future<Item = (A, B), Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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

FromRequest implementation for tuple

type Config = (A::Config, B::Config, C::Config)

type Result = Box<dyn Future<Item = (A, B, C), Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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, 

FromRequest implementation for tuple

type Config = (A::Config, B::Config, C::Config, D::Config)

type Result = Box<dyn Future<Item = (A, B, C, D), Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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, 

FromRequest implementation for tuple

type Config = (A::Config, B::Config, C::Config, D::Config, E::Config)

type Result = Box<dyn Future<Item = (A, B, C, D, E), Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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, 

FromRequest implementation for tuple

type Config = (A::Config, B::Config, C::Config, D::Config, E::Config, F::Config)

type Result = Box<dyn Future<Item = (A, B, C, D, E, F), Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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, 

FromRequest implementation for tuple

type Config = (A::Config, B::Config, C::Config, D::Config, E::Config, F::Config, G::Config)

type Result = Box<dyn Future<Item = (A, B, C, D, E, F, G), Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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, 

FromRequest implementation for tuple

type Config = (A::Config, B::Config, C::Config, D::Config, E::Config, F::Config, G::Config, H::Config)

type Result = Box<dyn Future<Item = (A, B, C, D, E, F, G, H), Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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, 

FromRequest implementation for tuple

type Config = (A::Config, B::Config, C::Config, D::Config, E::Config, F::Config, G::Config, H::Config, I::Config)

type Result = Box<dyn Future<Item = (A, B, C, D, E, F, G, H, I), Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

Loading content...

Implementors

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

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

type Config = EitherConfig<A, B, S>

type Result = AsyncResult<Either<A, B>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

impl<S> FromRequest<S> for Session

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!")
}

type Config = ()

type Result = Session

fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result

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

impl<S> FromRequest<S> for HttpRequest<S>

type Config = ()

type Result = Self

fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result

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

impl<S> FromRequest<S> for State<S>

type Config = ()

type Result = State<S>

fn from_request(req: &HttpRequest<S>, _: &Self::Config) -> Self::Result

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

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

type Config = FormConfig<S>

type Result = Box<dyn Future<Item = Self, Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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

type Config = JsonConfig<S>

type Result = Box<dyn Future<Item = Self, Error = Error>>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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

type Config = PathConfig<S>

type Result = Result<Self, Error>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

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

type Config = QueryConfig<S>

type Result = Result<Self, Error>

fn from_request(req: &HttpRequest<S>, cfg: &Self::Config) -> Self::Result

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

Loading content...