Enum Word 

pub enum Word<'a> {
    Token(&'a [u8]),
    Quoted(Quoted<'a>),
}

token / quoted-string: the value form of parameters and directives.

A token and a quoted string with the same content compare equal, as RFC 9110 section 5.6.6 requires: eq_bytes and eq_ignore_ascii_case compare unescaped content. The derived PartialEq compares the forms structurally.

Examples

use parse_net::text;

let (a, _) = text::parse_word(b"utf-8")?;
let (b, _) = text::parse_word(b"\"UTF-8\"")?;
assert!(a.eq_ignore_ascii_case(b"UTF-8") && b.eq_ignore_ascii_case(b"utf-8"));
assert_eq!(b.as_str(), Some("UTF-8"));

Variants

Token(&'a [u8])

A token.

Quoted(Quoted<'a>)

A quoted string.

Implementations

impl<'a> Word<'a>

pub const fn as_plain(&self) -> Option<&'a [u8]>

The token, or the quoted content when it has no quoted pair.

Examples

use parse_net::text::parse_word;

assert_eq!(parse_word(b"gzip")?.0.as_plain(), Some(&b"gzip"[..]));
assert_eq!(parse_word(b"\"a\\\"b\"")?.0.as_plain(), None);

pub fn as_str(&self) -> Option<&'a str>

as_plain when it is valid UTF-8.

Examples

use parse_net::text::parse_word;

assert_eq!(parse_word(b"\"caf\xc3\xa9\"")?.0.as_str(), Some("caf\u{e9}"));
assert_eq!(parse_word(b"\"\xff\"")?.0.as_str(), None);

pub fn eq_bytes(&self, other: &[u8]) -> bool

Whether the unescaped value equals other.

Examples

use parse_net::text::parse_word;

assert!(parse_word(b"\"a b\"")?.0.eq_bytes(b"a b"));
assert!(parse_word(b"gzip")?.0.eq_bytes(b"gzip") && !parse_word(b"gzip")?.0.eq_bytes(b"GZIP"));

pub fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool

Whether the unescaped value equals other ignoring ASCII case.

Examples

use parse_net::text::parse_word;

assert!(parse_word(b"GZIP")?.0.eq_ignore_ascii_case(b"gzip"));
assert!(parse_word(b"\"Br\"")?.0.eq_ignore_ascii_case(b"br"));

pub fn unescape_into<'b>( &self, out: &'b mut [u8], ) -> Result<&'b [u8], ParseError>

Writes the unescaped value into out and returns the written part.

Errors

ErrorKind::BufferTooSmall; nothing is written.

Examples

use parse_net::{text::parse_word, ErrorKind};

let (w, _) = parse_word(b"\"a\\\"b\"")?;
let mut buf = [0u8; 8];
assert_eq!(w.unescape_into(&mut buf)?, b"a\"b");
assert_eq!(w.unescape_into(&mut [0u8; 2]).unwrap_err().kind(), ErrorKind::BufferTooSmall);

pub fn len(&self) -> usize

The length of the unescaped value.

Examples

use parse_net::text::parse_word;

assert_eq!(parse_word(b"\"a\\\"b\"")?.0.len(), 3);
assert_eq!(parse_word(b"gzip")?.0.len(), 4);

pub fn is_empty(&self) -> bool

Whether the unescaped value is empty (only a quoted string can be).

Examples

use parse_net::text::parse_word;

assert!(parse_word(b"\"\"")?.0.is_empty());
assert!(!parse_word(b"x")?.0.is_empty());

Trait Implementations

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

impl<'a> Debug for Word<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for Word<'a>

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

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for Word<'a>