Struct `Params`

struct Params<'k, 'v> { ... }

A list of parameters returned by a route match.

# fn main() -> Result<(), Box<dyn std::error::Error>> {
# let mut router = matchit::Router::new();
# router.insert("/users/{id}", true).unwrap();
let matched = router.at("/users/1")?;

// Iterate through the keys and values.
for (key, value) in matched.params.iter() {
    println!("key: {}, value: {}", key, value);
}

// Get a specific value by name.
let id = matched.params.get("id");
assert_eq!(id, Some("1"));
# Ok(())
# }

Implementations

`impl<'k, 'v> Params<'k, 'v>`

fn len(self: &Self) -> usize: Returns the number of parameters.
fn get<impl AsRef<str>: AsRef<str>>(self: &Self, key: impl AsRef<str>) -> Option<&'v str>: Returns the value of the first parameter registered under the given key.
fn iter(self: &Self) -> ParamsIter<'_, 'k, 'v>: Returns an iterator over the parameters in the list.
fn is_empty(self: &Self) -> bool: Returns true if there are no parameters in the list.

`impl Debug for Params<'_, '_>`

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

`impl<'k, 'v> Clone for Params<'k, 'v>`

fn clone(self: &Self) -> Params<'k, 'v>

`impl<'k, 'v> Eq for Params<'k, 'v>`

`impl<'k, 'v> Freeze for Params<'k, 'v>`

`impl<'k, 'v> Ord for Params<'k, 'v>`

fn cmp(self: &Self, other: &Params<'k, 'v>) -> Ordering

`impl<'k, 'v> PartialEq for Params<'k, 'v>`

fn eq(self: &Self, other: &Params<'k, 'v>) -> bool

`impl<'k, 'v> PartialOrd for Params<'k, 'v>`

fn partial_cmp(self: &Self, other: &Params<'k, 'v>) -> Option<Ordering>

`impl<'k, 'v> RefUnwindSafe for Params<'k, 'v>`

`impl<'k, 'v> Send for Params<'k, 'v>`

`impl<'k, 'v> StructuralPartialEq for Params<'k, 'v>`

`impl<'k, 'v> Sync for Params<'k, 'v>`

`impl<'k, 'v> Unpin for Params<'k, 'v>`

`impl<'k, 'v> UnsafeUnpin for Params<'k, 'v>`

`impl<'k, 'v> UnwindSafe for Params<'k, 'v>`

`impl<T> Any for Params<'k, 'v>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Params<'k, 'v>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Params<'k, 'v>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Params<'k, 'v>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Params<'k, 'v>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Params<'k, 'v>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for Params<'k, 'v>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Params<'k, 'v>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Params<'k, 'v>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>