Struct QueryString

Source

pub struct QueryString(/* private fields */);

Expand description

§Query Parameters

let query = QueryString::from_iter([
    ("foo", "bar"),
    ("fizz", "buzz"),
]);

assert_eq!(query.first("foo"), Some("bar"));
assert_eq!(query.first("fizz"), Some("buzz"));
assert!(query.first("nonexistent").is_none());

Implementations§

Source §

impl QueryString

Source

pub fn first(&self, key: &str) -> Option<&str>

Returns the first occurrence of a value for a given key, if it exists.

let query = QueryString::from_iter([
    ("foo", "bar"),
    ("fizz", "buzz"),
    ("foo", "rab"),
]);

assert_eq!(query.first("foo"), Some("bar"));
assert_eq!(query.first("fizz"), Some("buzz"));
assert!(query.first("nonexistent").is_none());

Source

pub fn values_for(&self, key: &str) -> impl Iterator<Item = &str>

Provides an iterator over all values for a given key.

let query = QueryString::from_iter([
    ("foo", "bar"),
    ("fizz", "buzz"),
    ("foo", "rab"),
]);

let foos = query.values_for("foo").collect::<Vec<_>>();
assert_eq!(foos, vec!["bar", "rab"]);

Source

pub fn values_for_mut(&mut self, key: &str) -> impl Iterator<Item = &mut String>

Provides a mutable iterator over all values for a given key.

let mut query = QueryString::from_iter([
    ("foo", "bar"),
    ("fizz", "buzz"),
    ("foo", "rab"),
]);

for foo in query.values_for_mut("foo") {
    if foo != "bar" {
        foo.make_ascii_uppercase();
    }
}

let foos = query.values_for("foo").collect::<Vec<_>>();
assert_eq!(foos, vec!["bar", "RAB"]);
assert_eq!(query.first("fizz"), Some("buzz"));

Source

pub fn first_mut(&mut self, key: &str) -> Option<&mut String>

Returns a mutable reference to the first value for a given key, if it exists.

let mut query = QueryString::from_iter([
    ("foo", "bar"),
    ("fizz", "buzz"),
    ("foo", "rab"),
]);

if let Some(foo) = query.first_mut("foo") {
    foo.make_ascii_uppercase();
}
let foos = query.values_for("foo").collect::<Vec<_>>();
assert_eq!(foos, vec!["BAR", "rab"]);
assert_eq!(query.first("fizz"), Some("buzz"));

Source

pub fn delete_first(&mut self, key: &str) -> Option<String>

Deletes the first occurrence of a key and returns its value if found.

let mut query = QueryString::from_iter([
    ("foo", "bar"),
    ("fizz", "buzz"),
    ("foo", "rab"),
]);

let maybe_foo = query.delete_first("foo");
assert_eq!(maybe_foo.as_deref(), Some("bar"));
assert_eq!(query.first("foo"), Some("rab"));
assert_eq!(query.first("fizz"), Some("buzz"));

Source

pub fn delete_all(&mut self, key: &str) -> Vec<String>

Deletes all occurrences of a key and returns their values.

let mut query = QueryString::from_iter([
    ("foo", "bar"),
    ("fizz", "buzz"),
    ("foo", "rab"),
]);

let foos = query.delete_all("foo");
assert_eq!(foos, vec!["bar".to_string(), "rab".to_string()]);
assert_eq!(query.first("foo"), None);
assert_eq!(query.first("fizz"), Some("buzz"));

Source

pub fn add(&mut self, key: impl Into<String>, value: impl Into<String>)

Adds a new key-value pair to the query.

let mut query = QueryString::from_iter([("foo", "bar")]);

query.add("fizz", "buzz");
query.add("foo", "rab");

let foos = query.values_for("foo").collect::<Vec<_>>();
assert_eq!(query.first("foo"), Some("bar"));
assert_eq!(query.first("fizz"), Some("buzz"));
assert_eq!(foos, vec!["bar", "rab"]);

Source

pub fn insert_many<P, Q>(&mut self, params: P)
where P: IntoIterator<Item = Q>, Q: Into<QueryParameter>,

adds many key-value pairs to the query.

let mut query = QueryString::from_iter([("foo", "bar")]);

query.insert_many([
    ("fizz", "buzz"),
    ("foo", "rab"),
]);

let foos = query.values_for("foo").collect::<Vec<_>>();
assert_eq!(query.first("foo"), Some("bar"));
assert_eq!(query.first("fizz"), Some("buzz"));
assert_eq!(foos, vec!["bar", "rab"]);

Source

pub fn is_empty(&self) -> bool

Tests if the query is empty.

let some = QueryString::from_iter([("foo", "bar")]);
let none = QueryString::default();

assert!(!some.is_empty());
assert!(none.is_empty());

Source

pub fn len(&self) -> usize

Return the number of query parameters.

let some = QueryString::from_iter([("foo", "bar")]);
let none = QueryString::default();

assert_eq!(none.len(), 0);
assert_eq!(some.len(), 1);

Source

pub fn iter(&self) -> impl Iterator<Item = &QueryParameter>

Returns an iterator over the query parameters.

let query = QueryString::from_iter([
    ("foo", "bar"),
    ("fizz", "buzz"),
    ("foo", "rab"),
]);

let vals = query.iter().map(|p| p.value.as_str()).collect::<Vec<_>>();
assert_eq!(vals, vec!["bar", "buzz", "rab"]);

Source

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut QueryParameter>

Returns a mutable iterator over the query parameters.

let mut query = QueryString::from_iter([
    ("foo", "bar"),
    ("fizz", "buzz"),
    ("foo", "rab"),
]);

for param in query.iter_mut() {
    if param.key == "foo" {
        param.key.make_ascii_uppercase();
    } else {
        param.value.make_ascii_uppercase();
    }
}

let foos = query.values_for("FOO").collect::<Vec<_>>();

assert!(query.first("foo").is_none());
assert_eq!(query.first("fizz"), Some("BUZZ"));
assert_eq!(foos, vec!["bar", "rab"]);