pub enum Host<'host> {
IPv4Address(Ipv4Addr),
IPv6Address(Ipv6Addr),
RegisteredName(RegisteredName<'host>),
}Expand description
The host component of the authority as defined in [RFC3986, Section 3.2.2].
The RFC mentions support for future IP address literals. Of course, as of this moment there
exist none, so hosts of the form "[v*...]" where '*' is a hexadecimal digit and '...' is
the actual IP literal are not considered valid.
Also, the host is case-insensitive meaning that "example.com" and "ExAmPlE.CoM" refer to the
same host. Furthermore, percent-encoding plays no role in equality checking for characters in
the unreserved character set meaning that "example.com" and "ex%61mple.com" are identical.
Both of these attributes are reflected in the equality and hash functions.
However, be aware that just because percent-encoding plays no role in equality checking does not
mean that the host is normalized. If the host needs to be normalized, use the
Host::normalize function.
Variants§
IPv4Address(Ipv4Addr)
An IPv4 address. Based on the std’s implementation, leading zeros for octets are allowed
for up to three digits. So for example, "000.000.000.000" is still considered a valid IPv4
address, but "000.000.000.0000" is not. Thus, it would be considered a registered name.
IPv6Address(Ipv6Addr)
An IPv6 address. This will always be encased in brackets ('[' and ']').
RegisteredName(RegisteredName<'host>)
Any other host that does not follow the syntax of an IP address. This includes even hosts of
the form "999.999.999.999". One might expect this to produce an invalid IPv4 error, but
the RFC states that it is a “first-match-wins” algorithm, and that host does not match the
IPv4 literal syntax.
This may be changed in the future, since arguments can be made from either side.
Implementations§
Source§impl Host<'_>
impl Host<'_>
Sourcepub fn as_borrowed(&self) -> Host<'_>
pub fn as_borrowed(&self) -> Host<'_>
Returns a new host which is identical but has a lifetime tied to this host.
Sourcepub fn into_owned(self) -> Host<'static>
pub fn into_owned(self) -> Host<'static>
Converts the Host into an owned copy.
If you construct the host from a source with a non-static lifetime, you may run into lifetime problems due to the way the struct is designed. Calling this function will ensure that the returned value has a static lifetime.
This is different from just cloning. Cloning the host will just copy the references, and thus the lifetime will remain the same.
Sourcepub fn is_ipv4_address(&self) -> bool
pub fn is_ipv4_address(&self) -> bool
Returns whether the host is an IPv4 address.
§Examples
use std::convert::TryFrom;
use uriparse::Host;
let host = Host::try_from("192.168.1.1").unwrap();
assert!(host.is_ipv4_address());Sourcepub fn is_ipv6_address(&self) -> bool
pub fn is_ipv6_address(&self) -> bool
Returns whether the host is an IPv6 address.
§Examples
use std::convert::TryFrom;
use uriparse::Host;
let host = Host::try_from("[::1]").unwrap();
assert!(host.is_ipv6_address());Sourcepub fn is_normalized(&self) -> bool
pub fn is_normalized(&self) -> bool
Returns whether the host is normalized.
IPv4 and IPv6 hosts will always be normalized. Registered names are considered normalized if all characters are lowercase, no bytes that are in the unreserved character set are percent-encoded, and all alphabetical characters in percent-encodings are uppercase.
This function runs in constant-time.
§Examples
use std::convert::TryFrom;
use uriparse::Host;
let host = Host::try_from("192.168.1.1").unwrap();
assert!(host.is_normalized());
let mut host = Host::try_from("EXAMPLE.COM").unwrap();
assert!(!host.is_normalized());
host.normalize();
assert!(host.is_normalized());Sourcepub fn is_registered_name(&self) -> bool
pub fn is_registered_name(&self) -> bool
Returns whether the host is a registered name.
§Examples
use std::convert::TryFrom;
use uriparse::Host;
let host = Host::try_from("example.com").unwrap();
assert!(host.is_registered_name());Sourcepub fn normalize(&mut self)
pub fn normalize(&mut self)
Normalizes the host such that all characters are lowercase, no bytes that are in the unreserved character set are percent-encoded, and all alphabetical characters in percent-encodings are uppercase.
If the host is already normalized, the function will return immediately. Otherwise, if the host is not owned, this function will perform an allocation to clone it. The normalization itself though, is done in-place with no extra memory allocations required.
IPv4 and IPv6 hosts are always considered normalized.
§Examples
use std::convert::TryFrom;
use uriparse::Host;
let mut host = Host::try_from("192.168.1.1").unwrap();
host.normalize();
assert_eq!(host.to_string(), "192.168.1.1");
let mut host = Host::try_from("%ff%41").unwrap();
assert_eq!(host.to_string(), "%ff%41");
host.normalize();
assert_eq!(host.to_string(), "%FFA");