Enum vimwiki::vendor::uriparse::authority::Host

pub enum Host<'host> {
    IPv4Address(Ipv4Addr),
    IPv6Address(Ipv6Addr),
    RegisteredName(RegisteredName<'host>),
}

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

impl<'_> Host<'_>

pub fn as_borrowed(&self) -> Host<'_>

Returns a new host which is identical but has a lifetime tied to this host.

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.

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());

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());

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());

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());

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> Clone for Host<'host>

pub fn clone(&self) -> Host<'host>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'host> Debug for Host<'host>

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

Formats the value using the given formatter.

impl<'de, 'host> Deserialize<'de> for Host<'host>

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<Host<'host>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'_> Display for Host<'_>

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

Formats the value using the given formatter.

impl From<IpAddr> for Host<'static>

pub fn from(value: IpAddr) -> Host<'static>

Performs the conversion.

impl From<Ipv4Addr> for Host<'static>

pub fn from(value: Ipv4Addr) -> Host<'static>

Performs the conversion.

impl From<Ipv6Addr> for Host<'static>

pub fn from(value: Ipv6Addr) -> Host<'static>

Performs the conversion.

impl<'host> Hash for Host<'host>

pub 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, 

Feeds a slice of this type into the given Hasher.

impl<'host> PartialEq<Host<'host>> for Host<'host>

pub fn eq(&self, other: &Host<'host>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Host<'host>) -> bool

This method tests for !=.

impl<'host> Serialize for Host<'host>

pub fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'host> TryFrom<&'host [u8]> for Host<'host>

type Error = HostError

The type returned in the event of a conversion error.

pub fn try_from(
    value: &'host [u8]
) -> Result<Host<'host>, <Host<'host> as TryFrom<&'host [u8]>>::Error>

Performs the conversion.

impl<'host> TryFrom<&'host str> for Host<'host>

type Error = HostError

The type returned in the event of a conversion error.

pub fn try_from(
    value: &'host str
) -> Result<Host<'host>, <Host<'host> as TryFrom<&'host str>>::Error>

Performs the conversion.

impl<'host> Eq for Host<'host>

impl<'host> StructuralEq for Host<'host>

impl<'host> StructuralPartialEq for Host<'host>