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
sourceimpl 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");
Trait Implementations
impl<'host> Eq for Host<'host>
impl<'host> StructuralEq for Host<'host>
impl<'host> StructuralPartialEq for Host<'host>
Auto Trait Implementations
impl<'host> RefUnwindSafe for Host<'host>
impl<'host> Send for Host<'host>
impl<'host> Sync for Host<'host>
impl<'host> Unpin for Host<'host>
impl<'host> UnwindSafe for Host<'host>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more