Enum Host 

pub enum Host<S> {
    Ip(IpAddr),
    Domain(S),
}

The host name

Variants

Ip(IpAddr)

An IP address

Domain(S)

A DNS domain name

Implementations

impl<S> Host<S>

pub const fn is_ip(&self) -> bool

Returns true if this value is of type Ip. Returns false otherwise

pub const fn is_domain(&self) -> bool

Returns true if this value is of type Domain. Returns false otherwise

impl<S> Host<S>

pub fn unwrap_ip(self) -> IpAddr

Unwraps this value to the Host::Ip variant. Panics if this value is of any other type.

pub fn unwrap_ip_ref(&self) -> &IpAddr

Unwraps this reference to the Host::Ip variant. Panics if this value is of any other type.

pub fn unwrap_ip_mut(&mut self) -> &mut IpAddr

Unwraps this mutable reference to the Host::Ip variant. Panics if this value is of any other type.

pub fn unwrap_domain(self) -> S

Unwraps this value to the Host::Domain variant. Panics if this value is of any other type.

pub fn unwrap_domain_ref(&self) -> &S

Unwraps this reference to the Host::Domain variant. Panics if this value is of any other type.

pub fn unwrap_domain_mut(&mut self) -> &mut S

Unwraps this mutable reference to the Host::Domain variant. Panics if this value is of any other type.

impl<'a> Host<&'a str>

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

Parses an ASCII Host from &str.

Unlike Host::try_from or Host::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::Host;

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

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

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

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

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

Example

use hostaddr::Host;

let host = Host::try_from_ascii_str("example.com").unwrap();
assert_eq!(host.as_bytes().unwrap_domain(), b"example.com");

let host = Host::try_from_ascii_str("127.0.0.1").unwrap();
assert_eq!(host.as_bytes().unwrap_ip(), "127.0.0.1".parse::<core::net::IpAddr>().unwrap());

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

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

Parses an ASCII Host from &[u8].

Unlike Host::try_from or Host::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::Host;

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

// This will return an error because the domain is not ASCII.
assert!(Host::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 = Host::try_from_ascii_bytes(b"xn--0zwm56d.xn--fiqs8s").unwrap();
assert_eq!(host.unwrap_domain(), b"xn--0zwm56d.xn--fiqs8s");

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

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

Example

use hostaddr::Host;

let domain = Host::try_from_ascii_bytes(b"example.com").unwrap();
assert_eq!(domain.as_str().unwrap_domain(), "example.com");

let host = Host::try_from_ascii_bytes(b"127.0.0.1").unwrap();
assert_eq!(host.as_str().unwrap_ip(), "127.0.0.1".parse::<core::net::IpAddr>().unwrap());

impl<S> Host<S>

pub const fn from_ip(ip: IpAddr) -> Host<S>

Creates a new Host from an IP address.

pub const fn is_ipv4(&self) -> bool

Returns true if the host is an Ipv4 address.

Example

use hostaddr::Host;

let host: Host<&str> = Host::from_ip("127.0.0.1".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::Host;

let host: Host<&str> = Host::from_ip("::1".parse().unwrap());
assert!(host.is_ipv6());

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

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

Example

use std::sync::Arc;
use hostaddr::Host;

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

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

where S: Deref,

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

Example

use std::{sync::Arc, net::IpAddr};
use hostaddr::Host;

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

let host: Host<Arc<str>> = "127.0.0.1".try_into().unwrap();
assert_eq!("127.0.0.1".parse::<IpAddr>().unwrap(), host.as_deref().unwrap_ip());

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

Returns Some(ip) if the host is an IP address.

Example

use hostaddr::Host;
use std::net::IpAddr;

let host: Host<String> = "127.0.0.1".parse().unwrap();
assert_eq!(Some("127.0.0.1".parse().unwrap()), host.ip().copied());

let host: Host<String> = "example.com".parse().unwrap();
assert!(host.ip().is_none());

pub const fn domain(&self) -> Option<&S>

Returns Some(domain) if the host is a domain name.

Example

use hostaddr::Host;

let host: Host<String> = "example.com".parse().unwrap();
assert_eq!(Some("example.com".to_string()), host.domain().cloned());

let host: Host<String> = "127.0.0.1".parse().unwrap();
assert!(host.domain().is_none());

impl<S> Host<&S>

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

where S: Copy,

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

Example

use hostaddr::{Host, Buffer};
use std::net::IpAddr;

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

let host: Host<Buffer> = "127.0.0.1".parse().unwrap();
assert_eq!("127.0.0.1".parse::<IpAddr>().unwrap(), host.as_ref().copied().unwrap_ip());

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

where S: Clone,

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

Example

use hostaddr::Host;
use std::net::IpAddr;

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

let host: Host<String> = "127.0.0.1".parse().unwrap();
assert_eq!("127.0.0.1".parse::<IpAddr>().unwrap(), host.as_ref().cloned().unwrap_ip());

Trait Implementations

impl<S> CheapClone for Host<S>

where S: CheapClone,

fn cheap_clone(&self) -> Self

Returns a copy of the value.

impl<S> Clone for Host<S>

where S: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Host<S>

where S: Debug,

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

Formats the value using the given formatter.

impl<S> Display for Host<S>

where S: Display,

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

Formats the value using the given formatter.

impl<S> From<Domain<S>> for Host<S>

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

use hostaddr::{Domain, Host};

let domain: Domain<String> = "example.com".parse().unwrap();
let host: Host<String> = domain.into();

impl<S> From<IpAddr> for Host<S>

fn from(value: IpAddr) -> Host<S>

use hostaddr::Host;
use std::net::IpAddr;

let ip: IpAddr = "127.0.0.1".parse().unwrap();
let host: Host<String> = ip.into();

impl<S> From<Ipv4Addr> for Host<S>

fn from(value: Ipv4Addr) -> Host<S>

use hostaddr::Host;
use std::net::Ipv4Addr;

let ip: Ipv4Addr = "127.0.0.1".parse().unwrap();
let host: Host<String> = ip.into();

impl<S> From<Ipv6Addr> for Host<S>

fn from(value: Ipv6Addr) -> Host<S>

use hostaddr::Host;
use std::net::Ipv6Addr;

let ip: Ipv6Addr = "::1".parse().unwrap();
let host: Host<String> = ip.into();

impl<S> FromStr for Host<S>

where Domain<S>: FromStr,

type Err = ParseHostError

The associated error which can be returned from parsing.

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

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

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

where S: Ord,

fn cmp(&self, other: &Host<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 Host<S>

where S: PartialEq,

fn eq(&self, other: &Host<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 Host<S>

where S: PartialOrd,

fn partial_cmp(&self, other: &Host<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 Host<S>

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

type Error = ParseHostError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<S> Copy for Host<S>

where S: Copy,

impl<S> Eq for Host<S>

where S: Eq,

impl<S> StructuralPartialEq for Host<S>