Struct ValueField 

pub struct ValueField<'r> {
    pub name: NameView<'r>,
    pub value: &'r str,
}

A form field with a string value.

Rocket preprocesses all form fields into either ValueFields or DataFields. All fields from url-encoded forms, and fields without Content-Types from multipart forms, are preprocessed as a ValueField.

Fields

name: NameView<'r>

The (decoded) name of the form field.

value: &'r str

The (decoded) value of the form field.

Implementations

impl<'v> ValueField<'v>

pub fn parse(field: &'v str) -> Self

Parse a field string, where both the key and value are assumed to be URL-decoded while preserving the = delimiter, into a ValueField.

This implements 3.2, 3.3 of section 5.1 of the WHATWG living standard.

Example

use rocket::form::ValueField;

let parsed = ValueField::parse("a cat=an A+ pet");
assert_eq!(parsed.name, "a cat");
assert_eq!(parsed.value, "an A+ pet");

let parsed = ValueField::parse("a cat is an A+ pet");
assert_eq!(parsed.name, "a cat is an A+ pet");
assert_eq!(parsed.value, "");

let parsed = ValueField::parse("cat.food=yum?");
assert_eq!(parsed.name, "cat");
assert_eq!(parsed.name.source(), "cat.food");
assert_eq!(parsed.value, "yum?");

pub fn from_value(value: &'v str) -> Self

Create a ValueField from a value, which is assumed to be URL-decoded. The field name will be empty.

This is equivalent to ValueField::from(("", value)). To create a ValueField from both a name and a value, use ValueField::from((name, value)).

Example

use rocket::form::ValueField;

let parsed = ValueField::from_value("A+=kitten");
assert_eq!(parsed.name, "");
assert_eq!(parsed.value, "A+=kitten");

pub fn shift(self) -> Self

Shift the name of self and return self with the shifted name.

See NameView::shift() for the details on name “shifting”.

Example

use rocket::form::ValueField;

let parsed = ValueField::parse("cat.food=yum?");
assert_eq!(parsed.name, "cat");
assert_eq!(parsed.name.source(), "cat.food");
assert_eq!(parsed.name.key_lossy(), "cat");

let shifted = parsed.shift();
assert_eq!(shifted.name, "cat.food");
assert_eq!(shifted.name.key_lossy(), "food");

pub fn unexpected(&self) -> Error<'v>

Creates a complete unexpected value field Error from self.

The error will have the following properties:

• kind: ErrorKind::Unexpected
• name: self.name.source()
• value: self.value
• entity: Entity::ValueField

Example

use rocket::form::ValueField;
use rocket::form::error::{ErrorKind, Entity};

let field = ValueField::parse("cat.food=yum?");
let error = field.unexpected();

assert_eq!(error.name.as_ref().unwrap(), "cat.food");
assert_eq!(error.value.as_ref().unwrap(), "yum?");
assert_eq!(error.kind, ErrorKind::Unexpected);
assert_eq!(error.entity, Entity::ValueField);

pub fn missing(&self) -> Error<'v>

Creates a complete missing value field Error from self.

The error will have the following properties:

• kind: ErrorKind::Missing
• name: self.name.source()
• value: self.value
• entity: Entity::ValueField

Example

use rocket::form::ValueField;
use rocket::form::error::{ErrorKind, Entity};

let field = ValueField::parse("cat.food=yum?");
let error = field.missing();

assert_eq!(error.name.as_ref().unwrap(), "cat.food");
assert_eq!(error.value.as_ref().unwrap(), "yum?");
assert_eq!(error.kind, ErrorKind::Missing);
assert_eq!(error.entity, Entity::ValueField);

Trait Implementations

impl<'r> Clone for ValueField<'r>

fn clone(&self) -> ValueField<'r>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'r> Debug for ValueField<'r>

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

Formats the value using the given formatter.

impl<'a> From<(&'a str, &'a str)> for ValueField<'a>

fn from((name, value): (&'a str, &'a str)) -> Self

Converts to this type from the input type.

impl<'a, 'b> PartialEq<ValueField<'b>> for ValueField<'a>

fn eq(&self, other: &ValueField<'b>) -> 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.