Enum Host 

pub enum Host<'a> {
    Name(&'a [u8]),
    V4(Ipv4Addr),
    V6(Ipv6Addr),
    Future(&'a [u8]),
}

A host: a registered name, an IP address, or a future IP literal.

Variants

Name(&'a [u8])

A registered name (reg-name), as sent: case and a trailing dot are kept, %XX triples are not decoded. Empty when the field was empty.

V4(Ipv4Addr)

A dotted-decimal IPv4 address.

V6(Ipv6Addr)

A bracketed IPv6 address.

Future(&'a [u8])

A bracketed IPvFuture literal (vX.yyy), without the brackets.

Implementations

impl Host<'_>

pub fn eq_ignore_ascii_case(&self, other: &Host<'_>) -> bool

Whether two hosts are the same: names compared ASCII case-insensitively, IP literals by value.

Examples

use parse_net::host::parse_host;

assert!(parse_host(b"Example.com")?.eq_ignore_ascii_case(&parse_host(b"example.COM")?));
assert!(parse_host(b"[::1]")?.eq_ignore_ascii_case(&parse_host(b"[0:0::1]")?));

pub fn is_empty(&self) -> bool

Whether this is the empty name of an empty Host field.

pub fn write_to(&self, out: &mut impl Sink) -> Result<(), WriteError>

Writes the host: names as given, IPv6 bracketed in its RFC 5952 form.

Errors

WriteError::Full; nothing is written when the sink reports its room.

Examples

use parse_net::{host::parse_host, SliceSink};

let mut buf = [0u8; 64];
let mut out = SliceSink::new(&mut buf);
parse_host(b"[2001:DB8:0:0:0:0:0:1]")?.write_to(&mut out).expect("room");
assert_eq!(out.written(), b"[2001:db8::1]");

Trait Implementations

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

impl<'a> Debug for Host<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for Host<'a>

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

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for Host<'a>