Struct rocket::form::Strict

pub struct Strict<T>(/* private fields */);

A form guard for parsing form types strictly.

This type implements the FromForm trait and thus can be used as a generic parameter to the Form data guard: Form<Strict<T>>, where T implements FromForm. Unlike using Form directly, this type uses a strict parsing strategy: forms that contains a superset of the expected fields (i.e, extra fields) will fail to parse and defaults will not be use for missing fields.

Strictness

A Strict<T> will parse successfully from an incoming form only if the form contains the exact set of fields in T. Said another way, a Strict<T> will error on missing and/or extra fields. For instance, if an incoming form contains the fields “a”, “b”, and “c” while T only contains “a” and “c”, the form will not parse as Strict<T>.

Usage

Strict<T> implements FromForm as long as T implements FromForm. As such, Form<Strict<T>> is a data guard:

use rocket::form::{Form, Strict};

#[derive(FromForm)]
struct UserInput {
    value: String
}

#[post("/submit", data = "<user_input>")]
fn submit_task(user_input: Form<Strict<UserInput>>) -> String {
    format!("Your value: {}", user_input.value)
}

Strict can also be used to make individual fields strict while keeping the overall structure and remaining fields lenient:

use rocket::form::{Form, Strict};

#[derive(FromForm)]
struct UserInput {
    required: Strict<bool>,
    uses_default: bool
}

Implementations

impl<T> Strict<T>

pub fn into_inner(self) -> T

Consumes self and returns the inner value.

Note that since Strict implements Deref and DerefMut with target T, reading and writing an inner value can be accomplished transparently.

Example

use rocket::form::{Form, Strict};

#[derive(FromForm)]
struct MyForm {
    field: String,
}

#[post("/submit", data = "<form>")]
fn submit(form: Form<Strict<MyForm>>) -> String {
    // We can read or mutate a value transparently:
    let field: &str = &form.field;

    // To gain ownership, however, use `into_inner()`:
    form.into_inner().into_inner().field
}

Trait Implementations

impl<T: Debug> Debug for Strict<T>

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

Formats the value using the given formatter.

impl<T> Deref for Strict<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for Strict<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> From<T> for Strict<T>

fn from(val: T) -> Strict<T>

Converts to this type from the input type.

impl<'v, T: FromForm<'v>> FromForm<'v> for Strict<T>

type Context = <T as FromForm<'v>>::Context

The form guard’s parsing context.

fn init(_: Options) -> Self::Context

Initializes and returns the parsing context for Self.

fn push_value(ctxt: &mut Self::Context, field: ValueField<'v>)

Processes the value field field.

fn push_data<'life0, 'life1, 'async_trait>( ctxt: &'life0 mut Self::Context, field: DataField<'v, 'life1>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'v: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Processes the data field field.

fn finalize(this: Self::Context) -> Result<'v, Self>

Finalizes parsing. Returns the parsed value when successful or collection of Errors otherwise.

fn push_error(_ctxt: &mut Self::Context, _error: Error<'r>)

Processes the external form or field error _error.

fn default(opts: Options) -> Option<Self>

Returns a default value, if any, to use when a value is desired and parsing fails.

impl<'f, A, T: FromUriParam<Query, A> + FromForm<'f>> FromUriParam<Query, A> for Strict<T>

type Target = <T as FromUriParam<Query, A>>::Target

The resulting type of this conversion.

fn from_uri_param(param: A) -> Self::Target

Converts a value of type T into a value of type Self::Target. The resulting value of type Self::Target will be rendered into a URI using its UriDisplay implementation.

impl<T: Ord> Ord for Strict<T>

fn cmp(&self, other: &Strict<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for Strict<T>

fn eq(&self, other: &Strict<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: PartialOrd> PartialOrd for Strict<T>

fn partial_cmp(&self, other: &Strict<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq> Eq for Strict<T>

impl<T> StructuralPartialEq for Strict<T>