Struct HtmlForm

pub struct HtmlForm<T: DeserializeOwned + Send + 'static>(pub T);

Decodes an x-www-form-urlencoded request body (eg. sent by an HTML form).

This uses serde_urlencoded to deserialize the request body. The Content-Type and Content-Length headers are ignored.

Examples

Here’s an example decoding the following HTML form:

<form method="POST" action="/login">
    <input name="id" value="12345" type="hidden" />
    <input name="user" />
    <input name="password" type="password" />
    <input type="submit" value="Log In" />
</form>

#[derive(Deserialize)]
struct LoginData {
    id: u32,
    user: String,
    password: String,
}

#[derive(FromRequest)]
enum Route {
    #[post("/login")]
    LogIn {
        #[body]
        data: HtmlForm<LoginData>,
    },
}

let data = "id=12345&user=myuser&password=hunter2";

let Route::LogIn { data: HtmlForm(form) } = Route::from_request_sync(
    http::Request::post("/login").body(data.into()).unwrap(),
    NoContext,
).unwrap();

assert_eq!(form.id, 12345);
assert_eq!(form.user, "myuser");
assert_eq!(form.password, "hunter2");

Tuple Fields

0: T

Trait Implementations

impl<T: Debug + DeserializeOwned + Send + 'static> Debug for HtmlForm<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: DeserializeOwned + Send + 'static> DerefMut for HtmlForm<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T: DeserializeOwned + Send + 'static> FromBody for HtmlForm<T>

type Context = NoContext

A context parameter passed to from_body.

type Result = Box<dyn Future<Item = HtmlForm<T>, Error = Box<dyn Error + Send + Sync>> + Send>

The result returned by from_body.

fn from_body( _request: &Arc<Request<()>>, body: Body, _context: &Self::Context, ) -> Self::Result

Create an instance of this type from an HTTP request body, asynchronously.

impl<T: PartialEq + DeserializeOwned + Send + 'static> PartialEq for HtmlForm<T>

fn eq(&self, other: &HtmlForm<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: DeserializeOwned + Send + 'static> Deref for HtmlForm<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: Eq + DeserializeOwned + Send + 'static> Eq for HtmlForm<T>

impl<T: DeserializeOwned + Send + 'static> StructuralPartialEq for HtmlForm<T>