Struct OptionalParams 

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

Validated parameters from parse_optional. 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_optional(b"; server_no_context_takeover", &Limits::DEFAULT)?;
assert_eq!((p.len(), used), (1, 28));
assert!(p.contains("server_no_context_takeover"));
assert_eq!(format!("{p:?}"), "OptionalParams([\"server_no_context_takeover\"])");

Implementations

impl<'a> OptionalParams<'a>

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

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

Examples

use parse_net::{param, Limits};

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

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

The parameter named name (ASCII case-insensitive): the first match, or the last under DuplicatePolicy::Last. Its value tells a name sent alone from one sent with a value.

Examples

use parse_net::{param, Limits};

let (p, _) = param::parse_optional(b";client_max_window_bits;server_max_window_bits=10", &Limits::DEFAULT)?;
assert_eq!(p.find("CLIENT_MAX_WINDOW_BITS").map(|x| x.value), Some(None));
assert!(p.find("server_max_window_bits").and_then(|x| x.value).is_some_and(|v| v.eq_bytes(b"10")));
assert!(p.find("q").is_none());

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

Whether a parameter is named name (ASCII case-insensitive), with a value or without.

Examples

use parse_net::{param, Limits};

let (p, _) = param::parse_optional(b";server_no_context_takeover", &Limits::DEFAULT)?;
assert!(p.contains("Server_No_Context_Takeover"));
assert!(!p.contains("client_no_context_takeover"));

pub const fn len(&self) -> usize

The number of parameters.

Examples

use parse_net::{param, Limits};

assert_eq!(param::parse_optional(b";a;;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_optional(b"", &Limits::DEFAULT)?.0.is_empty());
assert!(!param::parse_optional(b";a", &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_optional(b";a ;b=2 , next", &Limits::DEFAULT)?;
assert_eq!(p.raw(), b";a ;b=2");

Trait Implementations

impl<'a> Clone for OptionalParams<'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 OptionalParams<'a>

impl Debug for OptionalParams<'_>

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

Formats the value using the given formatter.

impl<'a> Eq for OptionalParams<'a>

impl<'a> Hash for OptionalParams<'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 OptionalParams<'a>

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for OptionalParams<'a>