Struct DomainName 

pub struct DomainName(/* private fields */);

A validated domain name

This type guarantees that the contained string passes basic domain name validation (see module docs for validation rules). It’s immutable and provides access to the underlying string via as_str().

Construction

Use DomainName::new() to create a validated instance. The constructor validates the input and returns a Result with a detailed error if validation fails.

Serialization

Implements Serde traits with validation on deserialization. Invalid domain names will cause deserialization to fail with a descriptive error.

Implementations

impl DomainName

pub fn new(domain: &str) -> Result<DomainName, DomainNameError>

Creates a new validated domain name

Arguments

• domain - A string slice containing the domain name to validate

Errors

Returns DomainNameError if the domain name is invalid:

• EmptyDomain - Domain is empty
• InvalidFormat - Domain has typos or formatting issues

Examples

use torrust_tracker_deployer_types::DomainName;

let domain = DomainName::new("tracker.torrust.org").unwrap();
assert_eq!(domain.as_str(), "tracker.torrust.org");

pub fn as_str(&self) -> &str

Returns the domain name as a string slice

pub fn tld(&self) -> &str

Extracts the top-level domain (TLD)

Panics

This method will not panic because DomainName is validated at construction to always contain at least one dot (TLD separator).

Examples

use torrust_tracker_deployer_types::DomainName;

let domain = DomainName::new("api.tracker.torrust.org").unwrap();
assert_eq!(domain.tld(), "org");

pub fn subdomains(&self) -> Vec<&str>

Returns all subdomains as a vector (excluding TLD)

Examples

use torrust_tracker_deployer_types::DomainName;

let domain = DomainName::new("api.tracker.torrust.org").unwrap();
assert_eq!(domain.subdomains(), vec!["api", "tracker", "torrust"]);

Trait Implementations

impl AsRef<str> for DomainName

fn as_ref(&self) -> &str

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

impl Clone for DomainName

fn clone(&self) -> DomainName

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DomainName

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DomainName

fn deserialize<D>( deserializer: D, ) -> Result<DomainName, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DomainName

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

Formats the value using the given formatter.

impl Eq for DomainName

impl From<DomainName> for String

fn from(domain: DomainName) -> String

Converts to this type from the input type.

impl Hash for DomainName

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 JsonSchema for DomainName

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for DomainName

fn eq(&self, other: &DomainName) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for DomainName

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 StructuralPartialEq for DomainName

impl TryFrom<String> for DomainName

type Error = DomainNameError

The type returned in the event of a conversion error.

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

Performs the conversion.