Struct rocket::form::name::NameView

pub struct NameView<'v> { /* private fields */ }

A sliding-prefix view into a Name.

A NameView maintains a sliding key view into a Name. The current key (key()) can be shift()ed one key to the right. The Name prefix including the current key can be extracted via as_name() and the prefix not including the current key via parent().

This is best illustrated via an example:

use rocket::form::name::NameView;

// The view begins at the first key. Illustrated: `(a).b[c:d]` where
// parenthesis enclose the current key.
let mut view = NameView::new("a.b[c:d]");
assert_eq!(view.key().unwrap(), "a");
assert_eq!(view.as_name(), "a");
assert_eq!(view.parent(), None);

// Shifted once to the right views the second key: `a.(b)[c:d]`.
view.shift();
assert_eq!(view.key().unwrap(), "b");
assert_eq!(view.as_name(), "a.b");
assert_eq!(view.parent().unwrap(), "a");

// Shifting again now has predictable results: `a.b[(c:d)]`.
view.shift();
assert_eq!(view.key().unwrap(), "c:d");
assert_eq!(view.as_name(), "a.b[c:d]");
assert_eq!(view.parent().unwrap(), "a.b");

// Shifting past the end means we have no further keys.
view.shift();
assert_eq!(view.key(), None);
assert_eq!(view.key_lossy(), "");
assert_eq!(view.as_name(), "a.b[c:d]");
assert_eq!(view.parent().unwrap(), "a.b[c:d]");

view.shift();
assert_eq!(view.key(), None);
assert_eq!(view.as_name(), "a.b[c:d]");
assert_eq!(view.parent().unwrap(), "a.b[c:d]");

Equality

PartialEq, Eq, and Hash all operate on the name prefix including the current key. Only key values are compared; delimiters are insignificant. Again, illustrated via examples:

use rocket::form::name::NameView;

let mut view = NameView::new("a.b[c:d]");
assert_eq!(view, "a");

// Shifted once to the right views the second key: `a.(b)[c:d]`.
view.shift();
assert_eq!(view.key().unwrap(), "b");
assert_eq!(view.as_name(), "a.b");
assert_eq!(view, "a.b");
assert_eq!(view, "a[b]");

// Shifting again now has predictable results: `a.b[(c:d)]`.
view.shift();
assert_eq!(view, "a.b[c:d]");
assert_eq!(view, "a.b.c:d");
assert_eq!(view, "a[b].c:d");
assert_eq!(view, "a[b]c:d");

Implementations

impl<'v> NameView<'v>

pub fn new<N: Into<&'v Name>>(name: N) -> Self

Initializes a new NameView at the first key of name.

Example

use rocket::form::name::NameView;

let mut view = NameView::new("a.b[c:d]");
assert_eq!(view.key().unwrap(), "a");
assert_eq!(view.as_name(), "a");
assert_eq!(view.parent(), None);

pub fn shift(&mut self)

Shifts the current key once to the right.

Examples

use rocket::form::name::NameView;

let mut view = NameView::new("a.b[c:d][d.e]");
assert_eq!(view.key().unwrap(), "a");

view.shift();
assert_eq!(view.key().unwrap(), "b");

view.shift();
assert_eq!(view.key().unwrap(), "c:d");

view.shift();
assert_eq!(view.key().unwrap(), "d.e");

Malformed strings can have interesting results:

use rocket::form::name::NameView;

let mut view = NameView::new("a[c.d");
assert_eq!(view.key_lossy(), "a");

view.shift();
assert_eq!(view.key_lossy(), "c.d");

let mut view = NameView::new("a[c[.d]");
assert_eq!(view.key_lossy(), "a");

view.shift();
assert_eq!(view.key_lossy(), "c[.d");

view.shift();
assert_eq!(view.key(), None);

let mut view = NameView::new("foo[c[.d]]");
assert_eq!(view.key_lossy(), "foo");

view.shift();
assert_eq!(view.key_lossy(), "c[.d");

view.shift();
assert_eq!(view.key_lossy(), "]");

view.shift();
assert_eq!(view.key(), None);

pub fn key(&self) -> Option<&'v Key>

Returns the key currently viewed by self if it is non-empty.

                food.bart[bar:foo].blam[0_0][][1000]=some-value
name            |----------------------------------|
non-empty key   |--| |--| |-----|  |--| |-|     |--|
empty key                                  |-|

Example

use rocket::form::name::NameView;

let mut view = NameView::new("a[b]");
assert_eq!(view.key().unwrap(), "a");

view.shift();
assert_eq!(view.key().unwrap(), "b");

view.shift();
assert_eq!(view.key(), None);

pub fn key_lossy(&self) -> &'v Key

Returns the key currently viewed by self, even if it is non-empty.

                food.bart[bar:foo].blam[0_0][][1000]=some-value
name            |----------------------------------|
non-empty key   |--| |--| |-----|  |--| |-|     |--|
empty key                                  |-|

Example

use rocket::form::name::NameView;

let mut view = NameView::new("a[b]");
assert_eq!(view.key_lossy(), "a");

view.shift();
assert_eq!(view.key_lossy(), "b");

view.shift();
assert_eq!(view.key_lossy(), "");

pub fn as_name(&self) -> &'v Name

Returns the Name up to and including the current key.

Example

use rocket::form::name::NameView;

let mut view = NameView::new("a[b]");
assert_eq!(view.as_name(), "a");

view.shift();
assert_eq!(view.as_name(), "a[b]");

pub fn parent(&self) -> Option<&'v Name>

Returns the Name prior to the current key.

Example

use rocket::form::name::NameView;

let mut view = NameView::new("a[b]");
assert_eq!(view.parent(), None);

view.shift();
assert_eq!(view.parent().unwrap(), "a");

view.shift();
assert_eq!(view.parent().unwrap(), "a[b]");

pub fn source(&self) -> &'v Name

Returns the underlying Name.

Example

use rocket::form::name::NameView;

let mut view = NameView::new("a[b]");
assert_eq!(view.source(), "a[b]");

view.shift();
assert_eq!(view.source(), "a[b]");

view.shift();
assert_eq!(view.source(), "a[b]");

Trait Implementations

impl Borrow<Name> for NameView<'_>

fn borrow(&self) -> &Name

Immutably borrows from an owned value.

impl<'v> Clone for NameView<'v>

fn clone(&self) -> NameView<'v>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NameView<'_>

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

Formats the value using the given formatter.

impl Display for NameView<'_>

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

Formats the value using the given formatter.

impl<'v> From<NameView<'v>> for NameBuf<'v>

fn from(nv: NameView<'v>) -> Self

Converts to this type from the input type.

impl Hash for NameView<'_>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<B: PartialEq<Name>> PartialEq<B> for NameView<'_>

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

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

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

impl<'v> Copy for NameView<'v>

impl Eq for NameView<'_>