Struct HostAddr 

pub struct HostAddr<S> { /* private fields */ }

A host address, which consists of a Host and an optional port number.

Implementations

impl<S> HostAddr<S>

pub const fn new(host: Host<S>) -> HostAddr<S>

Create a new host address

Example

use hostaddr::HostAddr;

let host = HostAddr::<String>::new("example.com".parse().unwrap());
println!("{}", host);

pub fn from_domain(domain: Domain<S>) -> HostAddr<S>

Create a new host address from a domain name

Example

use hostaddr::{HostAddr, Domain};

let host = HostAddr::<String>::from_domain("example.com".parse().unwrap());
println!("{}", host);

pub const fn from_ip_addr(ip: IpAddr) -> HostAddr<S>

Create a new host address from an IP address

Example

use hostaddr::HostAddr;

let host = HostAddr::<String>::from_ip_addr("127.0.0.1".parse().unwrap());
println!("{}", host);

pub const fn from_sock_addr(addr: SocketAddr) -> HostAddr<S>

Create a new host address from a SocketAddr

Example

use hostaddr::HostAddr;

let host = HostAddr::<String>::from_sock_addr("127.0.0.1:8080".parse().unwrap());
println!("{}", host);

pub const fn host(&self) -> &Host<S>

Get the host name

Example

use hostaddr::HostAddr;

let addr: HostAddr<String> = "example.com:8080".parse().unwrap();
println!("{}", addr.host());

pub const fn ip(&self) -> Option<&IpAddr>

Get the ip address

Example

use hostaddr::HostAddr;

let addr: HostAddr<String> = HostAddr::from_ip_addr("127.0.0.1".parse().unwrap());
println!("{}", addr.ip().unwrap());

pub const fn port(&self) -> Option<u16>

Get the port number

Example

use hostaddr::HostAddr;

let addr: HostAddr<String> = "example.com:8080".parse().unwrap();

assert_eq!(Some(8080), addr.port());

pub const fn set_port(&mut self, port: u16) -> &mut HostAddr<S>

Set the port number

Example

use hostaddr::HostAddr;

let mut host: HostAddr<String> = "example.com".parse().unwrap();
host
  .set_port(8080)
  .set_host("example.org".parse().unwrap());
assert_eq!(Some(8080), host.port());

pub const fn maybe_port(&mut self, port: Option<u16>) -> &mut HostAddr<S>

Set the port number

See also maybe_with_port.

Example

use hostaddr::HostAddr;

let mut host: HostAddr<String> = "example.com".parse().unwrap();
host
  .maybe_port(Some(8080))
  .set_host("example.org".parse().unwrap());
assert_eq!(Some(8080), host.port());

pub const fn maybe_with_port(self, port: Option<u16>) -> HostAddr<S>

Set the port number

See also maybe_port.

Example

use hostaddr::HostAddr;

let host  = "example.com".parse::<HostAddr<String>>().unwrap().maybe_with_port(Some(8080));
assert_eq!(Some(8080), host.port());

pub const fn with_port(self, port: u16) -> HostAddr<S>

Set the port number

See also set_port.

Example

use hostaddr::HostAddr;

let host = "example.com".parse::<HostAddr<String>>().unwrap().with_port(8080);
assert_eq!(Some(8080), host.port());

pub const fn with_default_port(self, default: u16) -> HostAddr<S>

Set a default port if no port is currently set.

If a port is already set, this method does nothing.

Example

use hostaddr::HostAddr;

let addr = "example.com".parse::<HostAddr<String>>().unwrap()
  .with_default_port(443);
assert_eq!(Some(443), addr.port());

let addr = "example.com:8080".parse::<HostAddr<String>>().unwrap()
  .with_default_port(443);
assert_eq!(Some(8080), addr.port());

pub const fn clear_port(&mut self) -> &mut HostAddr<S>

Clear the port number.

Example

use hostaddr::HostAddr;

let mut addr: HostAddr<String> = "example.com:8080".parse().unwrap();
addr.clear_port();
assert_eq!(None, addr.port());

pub const fn has_port(&self) -> bool

Returns true if a port is set.

Example

use hostaddr::HostAddr;

let addr: HostAddr<String> = "example.com:8080".parse().unwrap();
assert!(addr.has_port());

let addr: HostAddr<String> = "example.com".parse().unwrap();
assert!(!addr.has_port());

pub fn set_host(&mut self, host: Host<S>) -> &mut HostAddr<S>

Set the host name

Example

use hostaddr::HostAddr;

let mut addr: HostAddr<String> = "example.com".parse().unwrap();
addr
  .set_host("example.org".parse().unwrap())
  .set_port(8080);
assert_eq!("example.org", addr.as_ref().host().unwrap_domain().as_str());

pub fn with_host(self, host: Host<S>) -> HostAddr<S>

Set the host name

Example

use hostaddr::HostAddr;

let addr: HostAddr<String> = HostAddr::from_sock_addr("127.0.0.1:8080".parse().unwrap())
  .with_host("example.com".parse().unwrap());
assert_eq!("example.com", addr.as_ref().host().unwrap_domain().as_str());

pub const fn is_ip(&self) -> bool

Returns true if the host is an IP address

Example

use hostaddr::HostAddr;

let host: HostAddr<String> = HostAddr::from_sock_addr("127.0.0.1:8080".parse().unwrap());
assert!(host.is_ip());

pub const fn is_ipv4(&self) -> bool

Returns true if the host is an Ipv4 address

Example

use hostaddr::HostAddr;

let host: HostAddr<String> = HostAddr::from_sock_addr("127.0.0.1:8080".parse().unwrap());
assert!(host.is_ipv4());

pub const fn is_ipv6(&self) -> bool

Returns true if the host is an Ipv6 address

Example

use hostaddr::HostAddr;

let host: HostAddr<String> = HostAddr::from_sock_addr("[::1]:8080".parse().unwrap());
assert!(host.is_ipv6());

pub const fn is_domain(&self) -> bool

Returns true if the host is a domain name

Example

use hostaddr::HostAddr;

let host: HostAddr<String> = "example.com".parse().unwrap();
assert!(host.is_domain());

pub fn is_localhost(&self) -> bool

where S: AsRef<str>,

Returns true if the host represents localhost.

This method checks if the host is:

• An IPv4 loopback address (127.0.0.0/8)
• An IPv6 loopback address (::1)
• The domain name “localhost”

Example

use hostaddr::HostAddr;

let addr = HostAddr::try_from_ascii_str("127.0.0.1").unwrap();
assert!(addr.is_localhost());

let addr = HostAddr::try_from_ascii_str("::1").unwrap();
assert!(addr.is_localhost());

let addr = HostAddr::try_from_ascii_str("localhost").unwrap();
assert!(addr.is_localhost());

let addr = HostAddr::try_from_ascii_str("example.com").unwrap();
assert!(!addr.is_localhost());

pub const fn to_socket_addr(&self) -> Option<SocketAddr>

Converts to a SocketAddr if the host is an IP address and a port is set.

Returns None if the host is a domain name or if no port is set.

Example

use hostaddr::HostAddr;
use std::net::{IpAddr, SocketAddr};

let addr: HostAddr<String> = "127.0.0.1:8080".parse().unwrap();
assert_eq!(
  Some(SocketAddr::new("127.0.0.1".parse::<IpAddr>().unwrap(), 8080)),
  addr.to_socket_addr()
);

// Domain names cannot be converted to SocketAddr
let addr: HostAddr<String> = "example.com:8080".parse().unwrap();
assert_eq!(None, addr.to_socket_addr());

// Missing port returns None
let addr: HostAddr<String> = "127.0.0.1".parse().unwrap();
assert_eq!(None, addr.to_socket_addr());

pub const fn as_ref(&self) -> HostAddr<&S>

Converts from &HostAddr<S> to HostAddr<&S>.

Example

use std::sync::Arc;
use hostaddr::HostAddr;

let host: HostAddr<Arc<str>> = "example.com:8080".try_into().unwrap();
assert_eq!("example.com", &**host.as_ref().host().unwrap_domain());

pub fn as_deref(&self) -> HostAddr<&<S as Deref>::Target>

where S: Deref,

Converts from HostAddr<S> (or &HostAddr<S>) to HostAddr<&S::Target>.

Example

use std::sync::Arc;
use hostaddr::HostAddr;

let host = "example.com:9090".parse::<HostAddr<Arc<str>>>().unwrap();
assert_eq!("example.com", host.as_deref().host().unwrap_domain());

pub fn into_components(self) -> (Host<S>, Option<u16>)

Consumes the HostAddr and returns the host name and port number.

Example

use hostaddr::HostAddr;

let host: HostAddr<String> = "example.com:8080".parse().unwrap();
let (host, port) = host.into_components();
assert_eq!("example.com", host.unwrap_domain().as_str());
assert_eq!(Some(8080), port);

pub fn unwrap_domain(self) -> (S, Option<u16>)

Unwraps the domain, panics if the host is an IP address.

Example

use hostaddr::HostAddr;

let host: HostAddr<String> = "example.com".parse().unwrap();
let (domain, port) = host.unwrap_domain();
assert_eq!("example.com", domain.as_str());
assert_eq!(None, port);

pub fn unwrap_ip(self) -> (IpAddr, Option<u16>)

Unwraps the IP address, panics if the host is a domain name.

Example

use hostaddr::HostAddr;

let host: HostAddr<String> = HostAddr::from_sock_addr("[::1]:8080".parse().unwrap());
let (ip, port) = host.unwrap_ip();
assert_eq!(ip, "::1".parse::<std::net::IpAddr>().unwrap());
assert_eq!(Some(8080), port);

impl<S> HostAddr<&S>

pub const fn copied(self) -> HostAddr<S>

where S: Copy,

Maps an HostAddr<&S> to an HostAddr<S> by copying the contents of the host addr.

Example

use hostaddr::{HostAddr, Buffer};

let host: HostAddr<Buffer> = HostAddr::try_from("example.com").unwrap();
assert_eq!("example.com", host.as_ref().copied().unwrap_domain().0.as_str());

pub fn cloned(self) -> HostAddr<S>

where S: Clone,

Maps an HostAddr<&S> to an HostAddr<S> by cloning the contents of the host addr.

Example

use hostaddr::HostAddr;

let host: HostAddr<String> = "example.com".parse().unwrap();
assert_eq!("example.com", host.as_ref().cloned().unwrap_domain().0.as_str());

impl<'a> HostAddr<&'a str>

pub fn try_from_ascii_str( input: &'a str, ) -> Result<HostAddr<&'a str>, ParseAsciiHostAddrError>

Parses a HostAddr name from &str.

Unlike HostAddr::try_from or HostAddr::from_str, this method does not perform any percent decoding or punycode decoding. If the input is not ASCII, it will return an error.

Example

use hostaddr::HostAddr;

let host = HostAddr::try_from_ascii_str("example.com").unwrap();
assert_eq!(host.unwrap_domain().0, "example.com");

// This will return an error because the domain is not ASCII.
assert!(HostAddr::try_from_ascii_str("测试.中国").is_err());

// Thie will not return an error, even though the human-readable domain is not ASCII.
let host = HostAddr::try_from_ascii_str("xn--0zwm56d.xn--fiqs8s").unwrap();
assert_eq!(host.unwrap_domain().0, "xn--0zwm56d.xn--fiqs8s");

pub const fn as_bytes(&self) -> HostAddr<&'a [u8]>

Converts the domain to a HostAddr<&'a [u8]>.

Example

use hostaddr::HostAddr;

let addr = HostAddr::try_from_ascii_str("example.com").unwrap();
assert_eq!(addr.as_bytes().unwrap_domain().0, b"example.com");

impl<'a> HostAddr<&'a [u8]>

pub fn try_from_ascii_bytes( input: &'a [u8], ) -> Result<HostAddr<&'a [u8]>, ParseAsciiHostAddrError>

Parses a HostAddr from &[u8].

Unlike HostAddr::try_from or HostAddr::from_str, this method does not perform any percent decoding or punycode decoding. If the input is not ASCII, it will return an error.

Example

use hostaddr::HostAddr;

let host = HostAddr::try_from_ascii_bytes(b"example.com").unwrap();
assert_eq!(host.unwrap_domain().0, b"example.com");

// This will return an error because the domain is not ASCII.
assert!(HostAddr::try_from_ascii_bytes("测试.中国".as_bytes()).is_err());

// Thie will not return an error, even though the human-readable domain is not ASCII.
let host = HostAddr::try_from_ascii_bytes(b"xn--0zwm56d.xn--fiqs8s").unwrap();
assert_eq!(host.unwrap_domain().0, b"xn--0zwm56d.xn--fiqs8s");

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

Converts the domain to a HostAddr<&'a str>.

Example

use hostaddr::HostAddr;

let addr = HostAddr::try_from_ascii_bytes(b"example.com").unwrap();
assert_eq!(addr.as_str().unwrap_domain().0, "example.com");

Trait Implementations

impl<S> CheapClone for HostAddr<S>

where S: CheapClone,

fn cheap_clone(&self) -> Self

Returns a copy of the value.

impl<S> Clone for HostAddr<S>

where S: Clone,

fn clone(&self) -> HostAddr<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Data for HostAddr<SmolStr>

type Ref<'a> = HostAddr<Buffer>

The reference type of the data.

fn from_ref( val: <HostAddr<SmolStr> as Data>::Ref<'_>, ) -> Result<HostAddr<SmolStr>, DecodeError>

where HostAddr<SmolStr>: Sized,

Converts the reference type to the owned type.

fn encoded_len(&self) -> usize

Returns the encoded length of the data only considering the data itself, (e.g. no length prefix, no wire type).

fn encode(&self, buf: &mut [u8]) -> Result<usize, EncodeError>

Encodes the message to a buffer.

const WIRE_TYPE: WireType = WireType::LengthDelimited

The wire type of the data.

fn encoded_len_with_length_delimited(&self) -> usize

Returns the encoded length of the data including the length delimited.

fn encode_to_vec(&self) -> Result<Vec<u8>, EncodeError>

Encodes the message into a vec.

fn encode_to_bytes(&self) -> Result<Bytes, EncodeError>

Encodes the message into a Bytes.

fn encode_length_delimited(&self, buf: &mut [u8]) -> Result<usize, EncodeError>

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Result<Vec<u8>, EncodeError>

Encodes the message with a length-delimiter into a vec.

fn encode_length_delimited_to_bytes(&self) -> Result<Bytes, EncodeError>

Encodes the message with a length-delimiter into a Bytes.

fn decode(src: &[u8]) -> Result<(usize, Self), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: &[u8]) -> Result<(usize, Self), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from the buffer.

impl<'a> DataRef<'a, HostAddr<SmolStr>> for HostAddr<Buffer>

fn decode(buf: &'a [u8]) -> Result<(usize, HostAddr<Buffer>), DecodeError>

Decodes the reference type from a buffer.

fn decode_length_delimited(src: &'a [u8]) -> Result<(usize, Self), DecodeError>

where Self: Sized,

Decodes a length-delimited reference instance of the message from the buffer.

impl<S> Debug for HostAddr<S>

where S: Debug,

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

Formats the value using the given formatter.

impl<S> Display for HostAddr<S>

where S: Display,

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

Formats the value using the given formatter.

impl<'a, S> From<&'a HostAddr<S>> for HostAddr<&'a Domain<S>>

fn from(value: &'a HostAddr<S>) -> HostAddr<&'a Domain<S>>

use hostaddr::{HostAddr, Domain};
use std::net::Ipv6Addr;

let ip = "::1".parse::<Ipv6Addr>().unwrap();
let addr = HostAddr::<String>::from(ip);

let domain_addr: HostAddr<&Domain<String>> = (&addr).into();

impl<S> From<(Domain<S>, u16)> for HostAddr<S>

fn from(_: (Domain<S>, u16)) -> HostAddr<S>

use hostaddr::{Domain, HostAddr};

let domain = Domain::<String>::try_from("example.com").unwrap();
let host = HostAddr::<String>::from((domain, 8080));

impl<S> From<(IpAddr, u16)> for HostAddr<S>

fn from(_: (IpAddr, u16)) -> HostAddr<S>

use hostaddr::HostAddr;
use std::net::IpAddr;

let ip = "127.0.0.1".parse::<IpAddr>().unwrap();
let addr = HostAddr::<String>::from((ip, 8080));

impl<S> From<(Ipv4Addr, u16)> for HostAddr<S>

fn from(_: (Ipv4Addr, u16)) -> HostAddr<S>

use hostaddr::HostAddr;
use std::net::Ipv4Addr;

let ip = "127.0.0.1".parse::<Ipv4Addr>().unwrap();
let addr = HostAddr::<String>::from((ip, 8080));

impl<S> From<(Ipv6Addr, u16)> for HostAddr<S>

fn from(_: (Ipv6Addr, u16)) -> HostAddr<S>

use hostaddr::HostAddr;
use std::net::Ipv6Addr;

let ip = "::1".parse::<Ipv6Addr>().unwrap();
let addr = HostAddr::<String>::from((ip, 8080));

impl<S> From<(u16, Domain<S>)> for HostAddr<S>

fn from(_: (u16, Domain<S>)) -> HostAddr<S>

use hostaddr::{Domain, HostAddr};

let domain = Domain::<String>::try_from("example.com").unwrap();
let host = HostAddr::<String>::from((8080, domain));

impl<S> From<(u16, IpAddr)> for HostAddr<S>

fn from(_: (u16, IpAddr)) -> HostAddr<S>

use hostaddr::HostAddr;
use std::net::IpAddr;

let ip = "::1".parse::<IpAddr>().unwrap();
let addr = HostAddr::<String>::from((8080, ip));

impl<S> From<Domain<S>> for HostAddr<S>

fn from(domain: Domain<S>) -> HostAddr<S>

use hostaddr::{Domain, HostAddr};

let domain = Domain::<String>::try_from("example.com").unwrap();
let host = HostAddr::<String>::from(domain);

impl<S> From<HostAddr<S>> for HostAddr<Domain<S>>

fn from(value: HostAddr<S>) -> HostAddr<Domain<S>>

use hostaddr::{HostAddr, Domain};
use std::net::Ipv6Addr;

let ip = "::1".parse::<Ipv6Addr>().unwrap();
let addr = HostAddr::<String>::from(ip);
let domain_addr: HostAddr<Domain<String>> = addr.into();

impl<S> From<IpAddr> for HostAddr<S>

fn from(ip: IpAddr) -> HostAddr<S>

use hostaddr::HostAddr;
use std::net::IpAddr;

let ip = "127.0.0.1".parse::<IpAddr>().unwrap();
let addr = HostAddr::<String>::from(ip);

impl<S> From<Ipv4Addr> for HostAddr<S>

fn from(ip: Ipv4Addr) -> HostAddr<S>

use hostaddr::HostAddr;
use std::net::Ipv4Addr;

let ip = "127.0.0.1".parse::<Ipv4Addr>().unwrap();
let addr = HostAddr::<String>::from(ip);

impl<S> From<Ipv6Addr> for HostAddr<S>

fn from(ip: Ipv6Addr) -> HostAddr<S>

use hostaddr::HostAddr;
use std::net::Ipv6Addr;

let ip = "::1".parse::<Ipv6Addr>().unwrap();
let addr = HostAddr::<String>::from(ip);

impl<S> From<SocketAddr> for HostAddr<S>

fn from(addr: SocketAddr) -> HostAddr<S>

use hostaddr::HostAddr;
use std::net::SocketAddr;

let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
let host = HostAddr::<String>::from(addr);

impl<S> From<SocketAddrV4> for HostAddr<S>

fn from(addr: SocketAddrV4) -> HostAddr<S>

use hostaddr::HostAddr;
use std::net::SocketAddrV4;

let addr = "127.0.0.1:8080".parse::<SocketAddrV4>().unwrap();
let host = HostAddr::<String>::from(addr);

impl<S> From<SocketAddrV6> for HostAddr<S>

fn from(addr: SocketAddrV6) -> HostAddr<S>

use hostaddr::HostAddr;
use std::net::SocketAddrV6;

let addr = "[::1]:8080".parse::<SocketAddrV6>().unwrap();
let host = HostAddr::<String>::from(addr);

impl<S> FromStr for HostAddr<S>

where Domain<S>: FromStr,

type Err = ParseHostAddrError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<HostAddr<S>, <HostAddr<S> as FromStr>::Err>

Parses a string s to return a value of this type.

impl<S> Hash for HostAddr<S>

where S: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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<S> Ord for HostAddr<S>

where S: Ord,

fn cmp(&self, other: &HostAddr<S>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<S> PartialEq for HostAddr<S>

where S: PartialEq,

fn eq(&self, other: &HostAddr<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S> PartialOrd for HostAddr<S>

where S: PartialOrd,

fn partial_cmp(&self, other: &HostAddr<S>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, S> TryFrom<&'a str> for HostAddr<S>

where Domain<S>: TryFrom<&'a str>,

type Error = ParseHostAddrError

The type returned in the event of a conversion error.

fn try_from( s: &'a str, ) -> Result<HostAddr<S>, <HostAddr<S> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a, S> TryFrom<(&'a str, u16)> for HostAddr<S>

where Domain<S>: TryFrom<&'a str>,

type Error = ParseHostAddrError

The type returned in the event of a conversion error.

fn try_from( _: (&'a str, u16), ) -> Result<HostAddr<S>, <HostAddr<S> as TryFrom<(&'a str, u16)>>::Error>

Performs the conversion.

impl<S> Copy for HostAddr<S>

where S: Copy,

impl<S> Eq for HostAddr<S>

where S: Eq,

impl<S> StructuralPartialEq for HostAddr<S>