Struct UrlSearchParams

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

Implementations

impl UrlSearchParams

pub fn parse<Input>(input: Input) -> Result<Self, ParseUrlError<Input>>

where Input: AsRef<str>,

Parses an return a UrlSearchParams struct.

use ada_url::UrlSearchParams;
let params = UrlSearchParams::parse("a=1&b=2")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
assert_eq!(params.get("a"), Some("1"));
assert_eq!(params.get("b"), Some("2"));

pub fn len(&self) -> usize

Returns the unique keys in a UrlSearchParams.

use ada_url::UrlSearchParams;
let params = UrlSearchParams::parse("a=1&b=2")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
assert_eq!(params.len(), 2);
let keys = params.keys().into_iter();
assert_eq!(keys.count(), params.len());

pub fn is_empty(&self) -> bool

Returns true if no entries exist in the UrlSearchParams.

pub fn sort(&mut self)

Sorts the keys of the UrlSearchParams struct.

pub fn append(&mut self, key: &str, value: &str)

Appends a key/value to the UrlSearchParams struct.

pub fn set(&mut self, key: &str, value: &str)

Removes all pre-existing keys from the UrlSearchParams struct and appends the new key/value.

use ada_url::UrlSearchParams;
let mut params = UrlSearchParams::parse("a=1&b=2")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
params.set("a", "3");
assert_eq!(params.get("a"), Some("3"));

pub fn remove_key(&mut self, key: &str)

Removes a key from the UrlSearchParams struct.

use ada_url::UrlSearchParams;
let mut params = UrlSearchParams::parse("a=1&b=2")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
params.remove_key("a");
assert_eq!(params.get("a"), None);

pub fn remove(&mut self, key: &str, value: &str)

Removes a key with a value from the UrlSearchParams struct.

use ada_url::UrlSearchParams;
let mut params = UrlSearchParams::parse("a=1&b=2")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
params.remove("a", "1");
assert_eq!(params.get("a"), None);

pub fn contains_key(&self, key: &str) -> bool

Returns whether the UrlSearchParams contains the key.

use ada_url::UrlSearchParams;
let params = UrlSearchParams::parse("a=1&b=2")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
assert_eq!(params.contains_key("a"), true);

pub fn contains(&self, key: &str, value: &str) -> bool

Returns whether the UrlSearchParams contains the key with the value.

use ada_url::UrlSearchParams;
let params = UrlSearchParams::parse("a=1&b=2")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
assert_eq!(params.contains("a", "1"), true);

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

Returns the value of the key.

use ada_url::UrlSearchParams;
let params = UrlSearchParams::parse("a=1&b=2")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
assert_eq!(params.get("a"), Some("1"));
assert_eq!(params.get("c"), None);

pub fn get_all(&self, key: &str) -> UrlSearchParamsEntry<'_>

Returns all values of the key.

use ada_url::UrlSearchParams;
let params = UrlSearchParams::parse("a=1&a=2")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
let pairs = params.get_all("a");
assert_eq!(pairs.len(), 2);

pub fn keys(&self) -> UrlSearchParamsKeyIterator<'_>

Returns all keys as an iterator

use ada_url::UrlSearchParams;
let params = UrlSearchParams::parse("a=1")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
let mut keys = params.keys();
assert!(keys.next().is_some());

pub fn values(&self) -> UrlSearchParamsValueIterator<'_>

Returns all values as an iterator

use ada_url::UrlSearchParams;
let params = UrlSearchParams::parse("a=1")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
let mut values = params.values();
assert!(values.next().is_some());

pub fn entries(&self) -> UrlSearchParamsEntryIterator<'_>

Returns all entries as an iterator

use ada_url::UrlSearchParams;
let params = UrlSearchParams::parse("a=1")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
let mut entries = params.entries();
assert_eq!(entries.next(), Some(("a", "1")));

Trait Implementations

impl Display for UrlSearchParams

Returns the stringified version of the UrlSearchParams struct.

use ada_url::UrlSearchParams;
let params = UrlSearchParams::parse("a=1&b=2")
    .expect("String should have been able to be parsed into an UrlSearchParams.");
assert_eq!(params.to_string(), "a=1&b=2");

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

Formats the value using the given formatter.

impl Drop for UrlSearchParams

fn drop(&mut self)

Executes the destructor for this type.

impl<Input> Extend<(Input, Input)> for UrlSearchParams

where Input: AsRef<str>,

fn extend<T: IntoIterator<Item = (Input, Input)>>(&mut self, iter: T)

Supports extending UrlSearchParams through an iterator.

 use ada_url::UrlSearchParams;
 let mut params = UrlSearchParams::parse("a=1&b=2")
     .expect("String should have been able to be parsed into an UrlSearchParams.");
 assert_eq!(params.len(), 2);
 params.extend([("foo", "bar")]);
 assert_eq!(params.len(), 3);

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<Input> FromIterator<(Input, Input)> for UrlSearchParams

where Input: AsRef<str>,

fn from_iter<T: IntoIterator<Item = (Input, Input)>>(iter: T) -> Self

Converts an iterator to UrlSearchParams

use ada_url::UrlSearchParams;
let iterator = std::iter::repeat(("hello", "world")).take(5);
let params = UrlSearchParams::from_iter(iterator);
assert_eq!(params.len(), 5);

impl FromStr for UrlSearchParams

type Err = ParseUrlError<Box<str>>

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for UrlSearchParams

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.