Struct LinkValue 

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

One link value: a target and its parameters.

Examples

use parse_net::{parse_link, Limits};

let v = parse_link(b"<https://x.test/>; rel=canonical", &Limits::DEFAULT)?.iter().next().expect("one link");
assert_eq!(v.target(), b"https://x.test/");
assert!(v.has_rel("canonical"));

Implementations

impl<'a> LinkValue<'a>

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

The URI-reference between < and >, as sent (not resolved).

Examples

use parse_net::{parse_link, Limits};

let v = parse_link(b"</docs/%7Euser>", &Limits::DEFAULT)?.iter().next().expect("one link");
assert_eq!(v.target(), b"/docs/%7Euser");

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

The parameters, in order.

Examples

use parse_net::{parse_link, Limits};

let v = parse_link(b"</a>; rel=next; crossorigin", &Limits::DEFAULT)?.iter().next().expect("one link");
let p = v.params();
assert_eq!(p.len(), 2);
assert!(p.iter().any(|(n, w)| n == b"crossorigin" && w.is_none()));

pub fn rel(&self) -> Option<Word<'a>>

The first rel value; later rel parameters are ignored (RFC 8288 section 3.3).

Examples

use parse_net::{parse_link, Limits};

let v = parse_link(b"</a>; rel=\"next last\"; rel=prev", &Limits::DEFAULT)?.iter().next().expect("one link");
assert!(v.rel().is_some_and(|w| w.eq_bytes(b"next last")));

pub fn rels(&self) -> RelIter<'a>

The relation types of the first rel, split on spaces. A relation type is a token or a URI, so it never needs a quoted pair; one that has one is yielded as sent.

Examples

use parse_net::{parse_link, Limits};

let v = parse_link(b"</a>; rel=\"next last\"", &Limits::DEFAULT)?.iter().next().expect("one link");
let rels: Vec<&[u8]> = v.rels().collect();
assert_eq!(rels, [&b"next"[..], b"last"]);

pub fn has_rel(&self, rel: &str) -> bool

Whether the first rel lists rel (ASCII case-insensitive).

Examples

use parse_net::{parse_link, Limits};

let l = parse_link(b"</style.css>; rel=\"Preload stylesheet\"", &Limits::DEFAULT)?;
let v = l.iter().next().expect("one link");
assert!(v.has_rel("preload") && v.has_rel("STYLESHEET") && !v.has_rel("style"));

pub fn anchor(&self) -> Option<Word<'a>>

The first anchor.

Examples

use parse_net::{parse_link, Limits};

let v = parse_link(b"</a>; rel=next; anchor=\"#top\"", &Limits::DEFAULT)?.iter().next().expect("one link");
assert!(v.anchor().is_some_and(|w| w.eq_bytes(b"#top")));

pub fn hreflang(&self) -> HreflangIter<'a>

Every hreflang, in order (the one parameter RFC 8288 lets repeat).

Examples

use parse_net::{parse_link, Limits};

let v = parse_link(b"</a>; rel=alternate; hreflang=en; hreflang=de", &Limits::DEFAULT)?.iter().next().expect("one link");
let langs: Vec<_> = v.hreflang().map(|w| w.as_str()).collect();
assert_eq!(langs, [Some("en"), Some("de")]);

pub fn title(&self) -> Option<Filename<'a>>

The title: the first title* (RFC 8187, decoded like filename*) when present, else the first title.

Examples

use parse_net::{parse_link, Limits};

let l = parse_link(b"<a>; title=\"EUR\"; title*=UTF-8''%E2%82%AC", &Limits::DEFAULT)?;
let mut buf = [0u8; 8];
let t = l.iter().next().and_then(|v| v.title()).expect("a title");
assert_eq!(t.decode_into(&mut buf)?, "\u{20ac}");

pub fn media(&self) -> Option<Word<'a>>

The first media.

Examples

use parse_net::{parse_link, Limits};

let v = parse_link(b"</s.css>; rel=stylesheet; media=\"screen\"", &Limits::DEFAULT)?.iter().next().expect("one link");
assert!(v.media().is_some_and(|w| w.eq_bytes(b"screen")));

pub fn type_(&self) -> Option<Word<'a>>

The first type.

Examples

use parse_net::{parse_link, Limits};

let v = parse_link(b"</a.json>; rel=alternate; type=\"application/json\"", &Limits::DEFAULT)?.iter().next().expect("one link");
assert!(v.type_().is_some_and(|w| w.eq_bytes(b"application/json")));

Trait Implementations

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

impl<'a> Debug for LinkValue<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for LinkValue<'a>

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

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for LinkValue<'a>