Struct Domain 

pub struct Domain<S>(/* private fields */)
where
    S: ?Sized;

A DNS domain name, as . dot-separated labels. Non-ASCII labels are encoded in punycode per IDNA if this is the host of a special URL, or percent encoded for non-special URLs.

Note

In this implementation, a fully-qualified domain name (FQDN) is valid. This means that the domain name can end with a . dot.

e.g.

• example.com. is a valid domain name, because it is a FQDN.
• A single . dot is a valid domain name, because it is root domain.

Example

use std::{sync::Arc, str::FromStr};

use hostaddr::Domain;

let domain = Domain::<String>::from_str("example.com").unwrap();
assert_eq!(domain.as_inner(), "example.com");

let domain = Domain::<String>::from_str("пример.испытание").unwrap();
assert_eq!(domain.as_inner(), "xn--e1afmkfd.xn--80akhbyknj4f");

let domain = Domain::<Arc<str>>::from_str("测试.中国").unwrap();
assert_eq!(domain.as_inner().as_ref(), "xn--0zwm56d.xn--fiqs8s");

let domain = Domain::<Arc<[u8]>>::try_from("test.com".as_bytes()).unwrap();
assert_eq!(domain.as_inner().as_ref(), b"test.com");

Implementations

impl<S> Domain<Domain<S>>

where S: ?Sized,

pub fn flatten(self) -> Domain<S>

Flattens a Domain<Domain<S>> into a Domain<S>.

pub const fn flatten_const(self) -> Domain<S>

where S: Copy,

Flattens a Domain<Domain<S>> into a Domain<S>.

impl<S> Domain<S>

where S: ?Sized,

pub const fn as_inner(&self) -> &S

Returns the reference to the inner S.

pub fn into_inner(self) -> S

Returns the inner S.

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

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

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

where S: Deref,

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

pub fn to_fqdn(&self) -> Option<Domain<Buffer>>

where S: AsRef<[u8]>,

Converts the domain to a fully qualified domain name (FQDN) by appending a dot (.) at the end if it is not already a FQDN.

Returns None if the domain is already a FQDN.

Domain Length Constraints

Valid domain names are at most 253 bytes long (or 254 bytes with trailing dot for FQDN). Since validation ensures these constraints, this method will always succeed for valid domains.

Example

use hostaddr::{Domain, Buffer};

// Regular domain to FQDN
let domain = Domain::<str>::try_from_ascii_str("example.com").unwrap();
let fqdn = domain.to_fqdn().unwrap();
assert_eq!(fqdn.as_ref().into_inner().as_str(), "example.com.");

// Already a FQDN
let domain = Domain::<str>::try_from_ascii_str("example.com.").unwrap();
assert!(domain.to_fqdn().is_none());

// Works with max-length domains (253 bytes)
let long_label = "a".repeat(63);
let long_domain = format!("{}.{}.{}.{}", long_label, long_label, long_label, &long_label[..61]);
let domain = Domain::<str>::try_from_ascii_str(&long_domain).unwrap();
assert_eq!(domain.as_ref().into_inner().len(), 253);
let fqdn = domain.to_fqdn().unwrap();
assert_eq!(fqdn.as_ref().into_inner().as_str().len(), 254);

pub fn is_fqdn(&self) -> bool

where S: AsRef<[u8]>,

Returns true if the domain is a fully qualified domain name (FQDN).

A FQDN is a domain name that ends with a dot (.), representing the DNS root.

Example

use hostaddr::Domain;

// Regular domain (not FQDN)
let domain = Domain::<str>::try_from_ascii_str("example.com").unwrap();
assert!(!domain.is_fqdn());

// FQDN (ends with dot)
let fqdn = Domain::<str>::try_from_ascii_str("example.com.").unwrap();
assert!(fqdn.is_fqdn());

// Root domain is a FQDN
let root = Domain::<str>::try_from_ascii_str(".").unwrap();
assert!(root.is_fqdn());

impl<S> Domain<&S>

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

where S: Copy,

Maps an Domain<&S> to an Domain<S> by copying the contents of the domain.

Example

use hostaddr::{Domain, Buffer};

let domain: Domain<Buffer> = Domain::try_from("example.com").unwrap();
assert_eq!("example.com", domain.as_ref().copied().as_inner().as_str());

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

where S: Clone,

Maps an Domain<&S> to an Domain<S> by cloning the contents of the domain.

Example

use hostaddr::Domain;

let domain: Domain<String> = "example.com".parse().unwrap();
assert_eq!("example.com", domain.as_ref().cloned().as_inner().as_str());

impl Domain<str>

pub const fn try_from_ascii_str( input: &str, ) -> Result<&Domain<str>, ParseAsciiDomainError>

Parses a domain name from &str.

Unlike Domain::try_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::Domain;

let domain = Domain::try_from_ascii_str("example.com").unwrap();
assert_eq!(domain.as_ref().into_inner(), "example.com");

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

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

pub const fn as_bytes(&self) -> &Domain<[u8]>

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

Example

use hostaddr::Domain;

let domain = Domain::try_from_ascii_str("example.com").unwrap();
assert_eq!(domain.as_bytes().as_ref().into_inner(), b"example.com");

impl Domain<[u8]>

pub const fn try_from_ascii_bytes( input: &[u8], ) -> Result<&Domain<[u8]>, ParseAsciiDomainError>

Parses a domain name from &[u8].

Unlike Domain::try_from_bytes, 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::Domain;

let domain = Domain::try_from_ascii_bytes(b"example.com").unwrap();
assert_eq!(domain.as_ref().into_inner(), b"example.com");

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

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

pub const fn as_str(&self) -> &Domain<str>

Converts the domain to a Domain<str>.

Example

use hostaddr::Domain;

let domain = Domain::try_from_ascii_bytes(b"example.com").unwrap();
assert_eq!(domain.as_str().as_ref().into_inner(), "example.com");

impl<S> Domain<S>

pub fn try_from_bytes( input: S, ) -> Result<Either<Domain<S>, Buffer>, ParseDomainError>

where S: AsRef<[u8]>,

Parses a domain name from &[u8].

If you can make sure the input is ASCII and not percent encoded, then Domain::try_from_ascii_bytes should be used instead.

Note

1. If the given input is encoded in percent encoding, it will be decoded.
2. If the given input is not ASCII, it will be converted to ASCII using punycode.
3. Otherwise, the input will be returned as is.

If the 1. & 2. happen, the result will be returned as a Either::Right(Buffer).

If the input is not a valid domain name, this method will return an error.

Example

use hostaddr::Domain;

let domain = Domain::try_from_bytes(b"example.com").unwrap();
assert_eq!(domain.unwrap_left().into_inner(), b"example.com");

let domain = Domain::try_from_bytes("测试.中国".as_bytes()).unwrap();
assert_eq!(domain.unwrap_right().as_bytes(), b"xn--0zwm56d.xn--fiqs8s");

let domain = Domain::try_from_bytes(b"example%2Ecom").unwrap();
assert_eq!(domain.unwrap_right().as_bytes(), b"example.com");

let domain = Domain::try_from_bytes("测试%2E中国".as_bytes()).unwrap();
assert_eq!(domain.unwrap_right().as_bytes(), b"xn--0zwm56d.xn--fiqs8s");

pub fn try_from_str( input: S, ) -> Result<Either<Domain<S>, Buffer>, ParseDomainError>

where S: AsRef<str>,

Parses a domain name from &str.

If you can make sure the input is ASCII and not percent encoded, then Domain::try_from_ascii_str should be used instead.

Note

1. If the given input is encoded in percent encoding, it will be decoded.
2. If the given input is not ASCII, it will be converted to ASCII using punycode.
3. Otherwise, the input will be returned as is.

If the 1. & 2. happen, the result will be returned as a Either::Right(Buffer).

If the input is not a valid domain name, this method will return an error.

Example

use hostaddr::Domain;

let domain = Domain::try_from_str("example.com").unwrap();
assert_eq!(domain.unwrap_left().into_inner(), "example.com");

let domain = Domain::try_from_str("测试.中国").unwrap();
assert_eq!(domain.unwrap_right().as_str(), "xn--0zwm56d.xn--fiqs8s");

let domain = Domain::try_from_str("example%2Ecom").unwrap();
assert_eq!(domain.unwrap_right().as_str(), "example.com");

let domain = Domain::try_from_str("测试%2E中国").unwrap();
assert_eq!(domain.unwrap_right().as_str(), "xn--0zwm56d.xn--fiqs8s");

Trait Implementations

impl<S> AsRef<[u8]> for Domain<S>

where S: AsRef<[u8]>,

fn as_ref(&self) -> &[u8]

use hostaddr::Domain;
use std::borrow::Borrow;

let domain = Domain::<[u8]>::try_from_ascii_bytes(b"example.com").unwrap();
let bytes: &[u8] = AsRef::as_ref(&domain);

assert_eq!(bytes, b"example.com");

impl<S> AsRef<S> for Domain<S>

where S: ?Sized,

fn as_ref(&self) -> &S

Converts this type into a shared reference of the (usually inferred) input type.

impl<S> AsRef<str> for Domain<S>

where S: AsRef<str>,

fn as_ref(&self) -> &str

use hostaddr::Domain;

let domain = Domain::<str>::try_from_ascii_str("example.com").unwrap();
let s: &str = AsRef::as_ref(&domain);

assert_eq!(s, "example.com");

impl<S> Borrow<S> for Domain<S>

where S: ?Sized,

fn borrow(&self) -> &S

use hostaddr::Domain;
use std::borrow::Borrow;

let domain = Domain::<[u8]>::try_from_ascii_bytes(b"example.com").unwrap();
let bytes: &[u8] = domain.borrow();

assert_eq!(bytes, b"example.com");

impl<S> CheapClone for Domain<S>

where S: CheapClone,

fn cheap_clone(&self) -> Self

Returns a copy of the value.

impl<S> Clone for Domain<S>

where S: Clone + ?Sized,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Data for Domain<SmolStr>

type Ref<'a> = Domain<Buffer>

The reference type of the data.

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

where Domain<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, Domain<SmolStr>> for Domain<Buffer>

fn decode(buf: &'a [u8]) -> Result<(usize, Domain<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 Domain<S>

where S: Debug + ?Sized,

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

Formats the value using the given formatter.

impl<S> Display for Domain<S>

where S: Display + ?Sized,

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

Formats the value using the given formatter.

impl From<&Domain<[u8]>> for Domain<Buffer>

fn from(value: &Domain<[u8]>) -> Domain<Buffer>

use hostaddr::{Domain, Buffer};

let domain: Domain<Buffer> = Domain::try_from_ascii_bytes(b"example.com").unwrap().into();
assert_eq!(domain.into_inner().as_bytes(), b"example.com");

impl From<&Domain<Buffer>> for Domain<Arc<[u8]>>

fn from(value: &Domain<Buffer>) -> Domain<Arc<[u8]>>

Converts to this type from the input type.

impl From<&Domain<Buffer>> for Domain<Arc<str>>

fn from(value: &Domain<Buffer>) -> Domain<Arc<str>>

Converts to this type from the input type.

impl From<&Domain<Buffer>> for Domain<Box<[u8]>>

fn from(value: &Domain<Buffer>) -> Domain<Box<[u8]>>

Converts to this type from the input type.

impl From<&Domain<Buffer>> for Domain<Box<str>>

fn from(value: &Domain<Buffer>) -> Domain<Box<str>>

Converts to this type from the input type.

impl From<&Domain<Buffer>> for Domain<Rc<[u8]>>

fn from(value: &Domain<Buffer>) -> Domain<Rc<[u8]>>

Converts to this type from the input type.

impl From<&Domain<Buffer>> for Domain<Rc<str>>

fn from(value: &Domain<Buffer>) -> Domain<Rc<str>>

Converts to this type from the input type.

impl From<&Domain<Buffer>> for Domain<SmolStr>

fn from(value: &Domain<Buffer>) -> Domain<SmolStr>

Converts to this type from the input type.

impl From<&Domain<Buffer>> for Domain<String>

fn from(value: &Domain<Buffer>) -> Domain<String>

Converts to this type from the input type.

impl From<&Domain<Buffer>> for Domain<Vec<u8>>

fn from(value: &Domain<Buffer>) -> Domain<Vec<u8>>

Converts to this type from the input type.

impl From<&Domain<str>> for Domain<Buffer>

fn from(value: &Domain<str>) -> Domain<Buffer>

use hostaddr::{Domain, Buffer};

let domain: Domain<Buffer> = Domain::try_from_ascii_str("example.com").unwrap().into();
assert_eq!(domain.into_inner().as_str(), "example.com");

impl From<Buffer> for Domain<Buffer>

fn from(value: Buffer) -> Domain<Buffer>

Converts to this type from the input type.

impl From<Domain<&[u8]>> for Domain<Buffer>

fn from(value: Domain<&[u8]>) -> Domain<Buffer>

use hostaddr::{Domain, Buffer};

let domain: Domain<Buffer> = Domain::try_from_ascii_bytes(b"example.com").unwrap().as_ref().into();
assert_eq!(domain.into_inner().as_str(), "example.com");

impl From<Domain<&str>> for Domain<Buffer>

fn from(value: Domain<&str>) -> Domain<Buffer>

use hostaddr::{Domain, Buffer};

let domain: Domain<Buffer> = Domain::try_from_ascii_str("example.com").unwrap().as_ref().into();
let buffer: Buffer = domain.into();
assert_eq!(buffer.as_str(), "example.com");

let domain: Domain<Buffer> = buffer.into();
assert_eq!(domain.into_inner().as_str(), "example.com");

impl From<Domain<Buffer>> for Buffer

fn from(value: Domain<Buffer>) -> Buffer

Converts to this type from the input type.

impl From<Domain<Buffer>> for Domain<Arc<[u8]>>

fn from(value: Domain<Buffer>) -> Domain<Arc<[u8]>>

Converts to this type from the input type.

impl From<Domain<Buffer>> for Domain<Arc<str>>

fn from(value: Domain<Buffer>) -> Domain<Arc<str>>

Converts to this type from the input type.

impl From<Domain<Buffer>> for Domain<Box<[u8]>>

fn from(value: Domain<Buffer>) -> Domain<Box<[u8]>>

Converts to this type from the input type.

impl From<Domain<Buffer>> for Domain<Box<str>>

fn from(value: Domain<Buffer>) -> Domain<Box<str>>

Converts to this type from the input type.

impl From<Domain<Buffer>> for Domain<Rc<[u8]>>

fn from(value: Domain<Buffer>) -> Domain<Rc<[u8]>>

Converts to this type from the input type.

impl From<Domain<Buffer>> for Domain<Rc<str>>

fn from(value: Domain<Buffer>) -> Domain<Rc<str>>

Converts to this type from the input type.

impl From<Domain<Buffer>> for Domain<SmolStr>

fn from(value: Domain<Buffer>) -> Domain<SmolStr>

Converts to this type from the input type.

impl From<Domain<Buffer>> for Domain<String>

fn from(value: Domain<Buffer>) -> Domain<String>

Converts to this type from the input type.

impl From<Domain<Buffer>> for Domain<Vec<u8>>

fn from(value: Domain<Buffer>) -> Domain<Vec<u8>>

Converts to this type from the input type.

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<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 FromStr for Domain<Arc<[u8]>>

type Err = ParseDomainError

The associated error which can be returned from parsing.

fn from_str( s: &str, ) -> Result<Domain<Arc<[u8]>>, <Domain<Arc<[u8]>> as FromStr>::Err>

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

impl FromStr for Domain<Arc<str>>

type Err = ParseDomainError

The associated error which can be returned from parsing.

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

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

impl FromStr for Domain<Box<[u8]>>

type Err = ParseDomainError

The associated error which can be returned from parsing.

fn from_str( s: &str, ) -> Result<Domain<Box<[u8]>>, <Domain<Box<[u8]>> as FromStr>::Err>

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

impl FromStr for Domain<Box<str>>

type Err = ParseDomainError

The associated error which can be returned from parsing.

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

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

impl FromStr for Domain<Buffer>

type Err = ParseDomainError

The associated error which can be returned from parsing.

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

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

impl FromStr for Domain<Rc<[u8]>>

type Err = ParseDomainError

The associated error which can be returned from parsing.

fn from_str( s: &str, ) -> Result<Domain<Rc<[u8]>>, <Domain<Rc<[u8]>> as FromStr>::Err>

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

impl FromStr for Domain<Rc<str>>

type Err = ParseDomainError

The associated error which can be returned from parsing.

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

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

impl FromStr for Domain<SmolStr>

type Err = ParseDomainError

The associated error which can be returned from parsing.

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

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

impl FromStr for Domain<String>

type Err = ParseDomainError

The associated error which can be returned from parsing.

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

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

impl FromStr for Domain<Vec<u8>>

type Err = ParseDomainError

The associated error which can be returned from parsing.

fn from_str( s: &str, ) -> Result<Domain<Vec<u8>>, <Domain<Vec<u8>> as FromStr>::Err>

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

impl<S> Hash for Domain<S>

where S: Hash + ?Sized,

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 Domain<S>

where S: Ord + ?Sized,

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

where S: PartialEq + ?Sized,

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

where S: PartialOrd + ?Sized,

fn partial_cmp(&self, other: &Domain<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> TryFrom<&'a [u8]> for Domain<Arc<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8], ) -> Result<Domain<Arc<[u8]>>, <Domain<Arc<[u8]>> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a [u8]> for Domain<Arc<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8], ) -> Result<Domain<Arc<str>>, <Domain<Arc<str>> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a [u8]> for Domain<Box<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8], ) -> Result<Domain<Box<[u8]>>, <Domain<Box<[u8]>> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a [u8]> for Domain<Box<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8], ) -> Result<Domain<Box<str>>, <Domain<Box<str>> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a [u8]> for Domain<Buffer>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8], ) -> Result<Domain<Buffer>, <Domain<Buffer> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a [u8]> for Domain<Cow<'a, [u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8], ) -> Result<Domain<Cow<'a, [u8]>>, <Domain<Cow<'a, [u8]>> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a [u8]> for Domain<Rc<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8], ) -> Result<Domain<Rc<[u8]>>, <Domain<Rc<[u8]>> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a [u8]> for Domain<Rc<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8], ) -> Result<Domain<Rc<str>>, <Domain<Rc<str>> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a [u8]> for Domain<SmolStr>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8], ) -> Result<Domain<SmolStr>, <Domain<SmolStr> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a [u8]> for Domain<String>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8], ) -> Result<Domain<String>, <Domain<String> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a [u8]> for Domain<Vec<u8>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8], ) -> Result<Domain<Vec<u8>>, <Domain<Vec<u8>> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a Arc<[u8]>> for Domain<Arc<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a Arc<[u8]>, ) -> Result<Domain<Arc<[u8]>>, <Domain<Arc<[u8]>> as TryFrom<&'a Arc<[u8]>>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a Arc<str>> for Domain<Arc<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a Arc<str>, ) -> Result<Domain<Arc<str>>, <Domain<Arc<str>> as TryFrom<&'a Arc<str>>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a Box<[u8]>> for Domain<Box<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a Box<[u8]>, ) -> Result<Domain<Box<[u8]>>, <Domain<Box<[u8]>> as TryFrom<&'a Box<[u8]>>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a Box<str>> for Domain<Box<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a Box<str>, ) -> Result<Domain<Box<str>>, <Domain<Box<str>> as TryFrom<&'a Box<str>>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a Rc<[u8]>> for Domain<Rc<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a Rc<[u8]>, ) -> Result<Domain<Rc<[u8]>>, <Domain<Rc<[u8]>> as TryFrom<&'a Rc<[u8]>>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a Rc<str>> for Domain<Rc<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a Rc<str>, ) -> Result<Domain<Rc<str>>, <Domain<Rc<str>> as TryFrom<&'a Rc<str>>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a SmolStr> for Domain<SmolStr>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a SmolStr, ) -> Result<Domain<SmolStr>, <Domain<SmolStr> as TryFrom<&'a SmolStr>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a String> for Domain<String>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a String, ) -> Result<Domain<String>, <Domain<String> as TryFrom<&'a String>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a Vec<u8>> for Domain<Vec<u8>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a Vec<u8>, ) -> Result<Domain<Vec<u8>>, <Domain<Vec<u8>> as TryFrom<&'a Vec<u8>>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Domain<Arc<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<Domain<Arc<[u8]>>, <Domain<Arc<[u8]>> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Domain<Arc<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<Domain<Arc<str>>, <Domain<Arc<str>> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Domain<Box<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<Domain<Box<[u8]>>, <Domain<Box<[u8]>> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Domain<Box<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<Domain<Box<str>>, <Domain<Box<str>> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Domain<Buffer>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<Domain<Buffer>, <Domain<Buffer> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Domain<Cow<'a, str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<Domain<Cow<'a, str>>, <Domain<Cow<'a, str>> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Domain<Rc<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<Domain<Rc<[u8]>>, <Domain<Rc<[u8]>> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Domain<Rc<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<Domain<Rc<str>>, <Domain<Rc<str>> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Domain<SmolStr>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<Domain<SmolStr>, <Domain<SmolStr> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Domain<String>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<Domain<String>, <Domain<String> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Domain<Vec<u8>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: &'a str, ) -> Result<Domain<Vec<u8>>, <Domain<Vec<u8>> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl TryFrom<Arc<[u8]>> for Domain<Arc<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: Arc<[u8]>, ) -> Result<Domain<Arc<[u8]>>, <Domain<Arc<[u8]>> as TryFrom<Arc<[u8]>>>::Error>

Performs the conversion.

impl TryFrom<Arc<str>> for Domain<Arc<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: Arc<str>, ) -> Result<Domain<Arc<str>>, <Domain<Arc<str>> as TryFrom<Arc<str>>>::Error>

Performs the conversion.

impl TryFrom<Box<[u8]>> for Domain<Box<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: Box<[u8]>, ) -> Result<Domain<Box<[u8]>>, <Domain<Box<[u8]>> as TryFrom<Box<[u8]>>>::Error>

Performs the conversion.

impl TryFrom<Box<str>> for Domain<Box<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: Box<str>, ) -> Result<Domain<Box<str>>, <Domain<Box<str>> as TryFrom<Box<str>>>::Error>

Performs the conversion.

impl TryFrom<Rc<[u8]>> for Domain<Rc<[u8]>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: Rc<[u8]>, ) -> Result<Domain<Rc<[u8]>>, <Domain<Rc<[u8]>> as TryFrom<Rc<[u8]>>>::Error>

Performs the conversion.

impl TryFrom<Rc<str>> for Domain<Rc<str>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: Rc<str>, ) -> Result<Domain<Rc<str>>, <Domain<Rc<str>> as TryFrom<Rc<str>>>::Error>

Performs the conversion.

impl TryFrom<SmolStr> for Domain<SmolStr>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: SmolStr, ) -> Result<Domain<SmolStr>, <Domain<SmolStr> as TryFrom<SmolStr>>::Error>

Performs the conversion.

impl TryFrom<String> for Domain<String>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: String, ) -> Result<Domain<String>, <Domain<String> as TryFrom<String>>::Error>

Performs the conversion.

impl TryFrom<Vec<u8>> for Domain<Vec<u8>>

type Error = ParseDomainError

The type returned in the event of a conversion error.

fn try_from( value: Vec<u8>, ) -> Result<Domain<Vec<u8>>, <Domain<Vec<u8>> as TryFrom<Vec<u8>>>::Error>

Performs the conversion.

impl<S> Copy for Domain<S>

where S: Copy + ?Sized,

impl<S> Eq for Domain<S>

where S: Eq + ?Sized,

impl<S> StructuralPartialEq for Domain<S>

where S: ?Sized,