Enum Query 

#[non_exhaustive]
pub enum Query<'r> {
    Absent,
    Null,
    One(&'r str),
    Many(&'r [Option<String>]),
}

Available on crate feature router only.

One value of route.query, as vue-router parses it: a key may be absent, given without a value (?flag, which is null), given once, or given more than once, which makes an array.

Example

use ferrovue::{Query, Router};

let router = Router::new(&["/search"]);
let route = router.at("/search?q=rust&tag=a&tag=b&flag");

assert_eq!(route.query("q"), Query::One("rust"));
assert_eq!(route.query("flag"), Query::Null);
assert_eq!(route.query("nothing"), Query::Absent);
assert!(route.query("tag").is_array());

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Absent

No such key: undefined.

Null

?flag: null.

One(&'r str)

?q=text, decoded.

Many(&'r [Option<String>])

?q=a&q=b: an array, in which a value written without = is null.

Implementations

impl<'r> Query<'r>

pub fn write_display(&self, out: &mut String)

{{ route.query.q }}, escaped: nothing for undefined and null, the text for a string, and an array as toDisplayString writes one: JSON.stringify(value, null, 2).

Example

let router = ferrovue::Router::new(&["/search"]);
let route = router.at("/search?q=a%3Cb&tag=x&tag=y");

let mut out = String::new();
route.query("q").write_display(&mut out);
assert_eq!(out, "a<b");

out.clear();
route.query("tag").write_display(&mut out);
assert_eq!(out, "[\n  "x",\n  "y"\n]");

pub fn truthy(&self) -> bool

JavaScript’s truthiness: a non-empty string or an array.

Example

use ferrovue::Query;

assert!(Query::One("x").truthy());
assert!(!Query::One("").truthy());
assert!(!Query::Null.truthy() && !Query::Absent.truthy());

pub fn is(&self, text: &str) -> bool

route.query.q === text: only a single value can equal a string.

pub fn is_undefined(&self) -> bool

route.query.q === undefined.

pub fn is_array(&self) -> bool

Array.isArray(route.query.q).

pub fn or<'a>(self, fallback: &'a str) -> Query<'a>

where 'r: 'a,

route.query.q ?? fallback: the fallback for undefined and null.

Example

use ferrovue::Query;

assert_eq!(Query::Absent.or("none"), Query::One("none"));
assert_eq!(Query::One("").or("none"), Query::One("")); // `??` keeps the empty string

pub fn attr_value(&self) -> Option<&'r str>

The single string, when the value is one: typeof route.query.q === "string", which narrows it to what an attribute can be bound to. null, undefined and an array are None.

Example

use ferrovue::Query;

assert_eq!(Query::One("rust").attr_value(), Some("rust"));
assert_eq!(Query::Null.attr_value(), None);

Trait Implementations

impl<'r> Clone for Query<'r>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'r> Copy for Query<'r>

impl<'r> Debug for Query<'r>

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

Formats the value using the given formatter.

impl<'r> PartialEq for Query<'r>

fn eq(&self, other: &Query<'r>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'r> StructuralPartialEq for Query<'r>