Struct rocket::form::Contextual

pub struct Contextual<'v, T> {
    pub value: Option<T>,
    pub context: Context<'v>,
}

An infallible form guard that records form fields and errors during parsing.

This form guard never fails. It should be use only when the form Context is required. In all other cases, prefer to use T directly.

Usage

Contextual acts as a proxy for any form type, recording all submitted form values and produced errors and associating them with their corresponding field name. Contextual is particularly useful for rendering forms with previously submitted values and errors associated with form input.

To retrieve the context for a form, use Form<Contextual<'_, T>> as a data guard, where T implements FromForm. The context field contains the form’s Context:

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

#[post("/submit", data = "<form>")]
fn submit(form: Form<Contextual<'_, T>>) {
    if let Some(ref value) = form.value {
        // The form parsed successfully. `value` is the `T`.
    }

    // We can retrieve raw field values and errors.
    let raw_id_value = form.context.field_value("id");
    let id_errors = form.context.field_errors("id");
}

Context serializes as a map, so it can be rendered in templates that require Serialize types. See the forms guide for further usage details.

Fields

value: Option<T>

The value, if it was successfully parsed, or None otherwise.

context: Context<'v>

The context with all submitted fields and associated values and errors.

Trait Implementations

impl<'v, T: Debug> Debug for Contextual<'v, T>

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

Formats the value using the given formatter.

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

type Context = (<T as FromForm<'v>>::Context, Context<'v>)

The form guard’s parsing context.

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

Initializes and returns the parsing context for Self.

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

Processes the value field field.

fn push_data<'life0, 'life1, 'async_trait>( (val_ctxt, 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 push_error((_, ctxt): &mut Self::Context, e: Error<'v>)

Processes the external form or field error _error.

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

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

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

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