Struct Hostname 

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

Available on crate feature net only.

A DNS hostname.

This type provides type-safe hostnames with RFC 1123 validation. It uses the newtype pattern with #[repr(transparent)] for zero-cost abstraction.

Invariants

• Total length is 1-253 characters
• Each label is 1-63 characters
• Only ASCII letters, digits, and hyphens are allowed
• Labels cannot start or end with hyphens
• Stored in lowercase for case-insensitive comparison

Examples

use bare_types::net::Hostname;

// Create a hostname
let hostname = Hostname::new("example.com")?;

// Access the string representation
assert_eq!(hostname.as_str(), "example.com");

// Check if it's localhost
assert!(!hostname.is_localhost());

// Iterate over labels
let labels: Vec<&str> = hostname.labels().collect();
assert_eq!(labels, vec!["example", "com"]);

// Parse from string
let hostname: Hostname = "www.example.com".parse()?;

Implementations

impl Hostname

pub fn new(s: &str) -> Result<Self, HostnameError>

Creates a new hostname from a string.

Errors

Returns HostnameError if the string does not comply with RFC 1123.

Examples

use bare_types::net::Hostname;

let hostname = Hostname::new("example.com")?;
assert_eq!(hostname.as_str(), "example.com");

pub fn as_str(&self) -> &str

Returns the hostname as a string slice.

Examples

use bare_types::net::Hostname;

let hostname = Hostname::new("example.com").unwrap();
assert_eq!(hostname.as_str(), "example.com");

pub const fn as_inner(&self) -> &String<253>

Returns a reference to the underlying heapless::String.

Examples

use bare_types::net::Hostname;

let hostname = Hostname::new("example.com").unwrap();
let inner: &heapless::String<253> = hostname.as_inner();
assert_eq!(inner.as_str(), "example.com");

pub fn into_inner(self) -> String<253>

Consumes this hostname and returns the underlying string.

Examples

use bare_types::net::Hostname;

let hostname = Hostname::new("example.com").unwrap();
let inner = hostname.into_inner();
assert_eq!(inner.as_str(), "example.com");

pub fn is_localhost(&self) -> bool

Returns true if this is the localhost hostname.

Examples

use bare_types::net::Hostname;

assert!(Hostname::new("localhost").unwrap().is_localhost());
assert!(!Hostname::new("example.com").unwrap().is_localhost());

pub fn labels(&self) -> impl Iterator<Item = &str>

Returns an iterator over the labels in this hostname.

Examples

use bare_types::net::Hostname;

let hostname = Hostname::new("www.example.com").unwrap();
let labels: Vec<&str> = hostname.labels().collect();
assert_eq!(labels, vec!["www", "example", "com"]);

Trait Implementations

impl<'a> Arbitrary<'a> for Hostname

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for Hostname

fn clone(&self) -> Hostname

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Hostname

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Hostname

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Hostname

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

Formats the value using the given formatter.

impl From<Hostname> for String<253>

fn from(hostname: Hostname) -> Self

Converts to this type from the input type.

impl FromStr for Hostname

type Err = HostnameError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl Hash for Hostname

fn hash<__H: Hasher>(&self, state: &mut __H)

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 Ord for Hostname

fn cmp(&self, other: &Hostname) -> 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 PartialEq for Hostname

fn eq(&self, other: &Hostname) -> 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 PartialOrd for Hostname

fn partial_cmp(&self, other: &Hostname) -> 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 Serialize for Hostname

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for Hostname

type Error = HostnameError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl Zeroize for Hostname

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Eq for Hostname

impl StructuralPartialEq for Hostname