Struct Params 

pub struct Params<'a> { /* private fields */ }

Validated parameters. Iterating them cannot fail.

Debug prints the parameter names only: values can be secrets.

Examples

use parse_net::{param, Limits};

let (p, used) = param::parse(b";q=1;level=\"2\"", &Limits::DEFAULT)?;
assert_eq!((p.len(), used), (2, 14));
assert!(p.get("level").is_some_and(|v| v.eq_bytes(b"2")));

Implementations

impl<'a> Params<'a>

pub fn iter(&self) -> ParamIter<'a>

Every parameter, in order (with First or Last, duplicates included).

Examples

use parse_net::{param, Limits};

let (p, _) = param::parse(b";a=1; B=2", &Limits::DEFAULT)?;
let names: Vec<&[u8]> = p.iter().map(|p| p.name).collect();
assert_eq!(names, [&b"a"[..], b"B"]);

pub fn get(&self, name: &str) -> Option<Word<'a>>

The value of the parameter named name (ASCII case-insensitive): the first match, or the last under DuplicatePolicy::Last.

Examples

use parse_net::{param, Limits};

let (p, _) = param::parse(b";charset=UTF-8", &Limits::DEFAULT)?;
assert!(p.get("CHARSET").is_some_and(|v| v.eq_bytes(b"UTF-8")));
assert!(p.get("q").is_none());

pub const fn len(&self) -> usize

The number of parameters.

Examples

use parse_net::{param, Limits};

assert_eq!(param::parse(b";a=1;;b=2;", &Limits::DEFAULT)?.0.len(), 2);

pub const fn is_empty(&self) -> bool

Whether there are no parameters.

Examples

use parse_net::{param, Limits};

assert!(param::parse(b"", &Limits::DEFAULT)?.0.is_empty());
assert!(!param::parse(b";a=1", &Limits::DEFAULT)?.0.is_empty());

pub const fn raw(&self) -> &'a [u8]

The validated text, from the first ; to the end of the last parameter.

Examples

use parse_net::{param, Limits};

let (p, _) = param::parse(b";a=1 ;b=2 , next", &Limits::DEFAULT)?;
assert_eq!(p.raw(), b";a=1 ;b=2");

Trait Implementations

impl<'a> Clone for Params<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Params<'a>

impl Debug for Params<'_>

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

Formats the value using the given formatter.

impl<'a> Eq for Params<'a>

impl<'a> Hash for Params<'a>

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<'a> PartialEq for Params<'a>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for Params<'a>