Struct HostPort 

pub struct HostPort<'a> {
    pub host: Host<'a>,
    pub port: Option<u16>,
    pub empty_port: bool,
}

A host and an optional port.

Examples

use parse_net::{parse_host_port, Host};

let hp = parse_host_port(b"example.com:")?;
assert_eq!((hp.host, hp.port, hp.empty_port), (Host::Name(b"example.com"), None, true));
assert_eq!(parse_host_port(b"example.com:8080")?.port, Some(8080));

Fields

host: Host<'a>

The host.

port: Option<u16>

The port, when digits followed the :.

empty_port: bool

Whether a : with no digits followed the host (example.com:), which RFC 3986 allows (port = *DIGIT).

Implementations

impl HostPort<'_>

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

Writes the host, then :port when there is a port.

Errors

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

Examples

use parse_net::{parse_host_port, SliceSink};

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

impl HostPort<'_>

pub fn to_owned(&self) -> OwnedHostPort

Available on crate feature alloc only.

Copies the value into an OwnedHostPort (one allocation for a name, none for an address).

Examples

use parse_net::{parse_host_port, Host};
use std::net::Ipv4Addr;

let owned = parse_host_port(b"192.0.2.1:443")?.to_owned();
assert_eq!(owned.as_view().port, Some(443));
assert_eq!(owned.as_view().host, Host::V4(Ipv4Addr::new(192, 0, 2, 1)));

Trait Implementations

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

impl<'a> Debug for HostPort<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for HostPort<'a>

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

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for HostPort<'a>