Struct MediaRange 

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

A validated media range from Accept.

Examples

use parse_net::{media, Limits};

let r = media::parse_range(b"text/html;level=1;q=0.7;ext=x", &Limits::DEFAULT)?;
assert_eq!(r.params().len(), 1);              // `level` only: `q` ends the media-type parameters
assert_eq!(r.weight().thousandths(), 700);
assert_eq!(r.specificity(), 4);

Implementations

impl<'a> MediaRange<'a>

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

The type, or *.

Examples

use parse_net::{media, Limits};

let r = media::parse_range(b"text/*", &Limits::DEFAULT)?;
assert_eq!(r.type_(), b"text");

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

The subtype, or *.

Examples

use parse_net::{media, Limits};

assert_eq!(media::parse_range(b"text/*", &Limits::DEFAULT)?.subtype(), b"*");
assert_eq!(media::parse_range(b"text/csv", &Limits::DEFAULT)?.subtype(), b"csv");

pub fn matches(&self, offer: &MediaType<'_>) -> bool

Whether this range matches offer: the type and subtype match (or are *), and every parameter of the range is present in the offer with an equal value (case-sensitive, except charset).

Examples

use parse_net::{media, parse_media_type, Limits};

let r = media::parse_range(b"text/html;charset=utf-8", &Limits::DEFAULT)?;
assert!(r.matches(&parse_media_type(b"text/html; charset=UTF-8")?));
assert!(!r.matches(&parse_media_type(b"text/html")?));

pub const fn specificity(&self) -> u8

How specific the range is: 4 for a type with parameters, 3 for an exact type, 2 for type/*, 1 for */*.

Examples

use parse_net::{media, Limits};

let s = |v: &[u8]| media::parse_range(v, &Limits::DEFAULT).map(|r| r.specificity());
assert_eq!((s(b"*/*")?, s(b"image/*")?, s(b"image/png")?, s(b"image/png;x=1")?), (1, 2, 3, 4));

pub const fn weight(&self) -> QValue

The weight (q), 1 when absent.

Examples

use parse_net::{media, Limits, QValue};

assert_eq!(media::parse_range(b"text/html;q=0.25", &Limits::DEFAULT)?.weight().thousandths(), 250);
assert_eq!(media::parse_range(b"text/html", &Limits::DEFAULT)?.weight(), QValue::ONE);

pub const fn params(&self) -> Params<'a>

The media-type parameters: those before q.

Examples

use parse_net::{media, Limits};

let r = media::parse_range(b"text/html;level=1;q=0.5", &Limits::DEFAULT)?;
assert_eq!(r.params().get("level").and_then(|w| w.as_str()), Some("1"));
assert!(r.params().get("q").is_none());

Trait Implementations

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

impl<'a> Debug for MediaRange<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for MediaRange<'a>

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

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for MediaRange<'a>