Struct addr_spec::AddrSpec

pub struct AddrSpec { /* private fields */ }

Address specification as defined in RFC 5322 with UTF-8 support as defined in RFC 6532.

Both the local part and the domain are normalized using the NFC as recommended in Section 3.1, RFC 6532. Address strings built using this crate work well for unique, UTF-8 identifiers.

If you intend to create an address specification from individual parts, make sure to validate both local part and domain using the is_valid_local_part and is_valid_domain functions before to_stringing the spec. You can also use the is_valid function to validate the whole address.

Examples

use std::str::FromStr;

use addr_spec::AddrSpec;

let addr_spec = AddrSpec::from_str("test@example.com").unwrap();
assert_eq!(addr_spec.local_part(), "test");
assert_eq!(addr_spec.domain(), "example.com");
assert_eq!(addr_spec.is_literal(), false);
assert_eq!(addr_spec.to_string(), "test@example.com");

Quoted local parts will be unescaped if possible:

use std::str::FromStr;

use addr_spec::AddrSpec;

let addr_spec = AddrSpec::from_str(r#""test"@example.com"#).unwrap();
assert_eq!(addr_spec.local_part(), "test");
assert_eq!(addr_spec.domain(), "example.com");
assert_eq!(addr_spec.is_literal(), false);
assert_eq!(addr_spec.to_string(), r#"test@example.com"#);

Literal domains are also supported:

use std::str::FromStr;

use addr_spec::AddrSpec;

let addr_spec = AddrSpec::from_str("test@[IPv6:2001:db8::1]").unwrap();
assert_eq!(addr_spec.local_part(), "test");
assert_eq!(addr_spec.domain(), "IPv6:2001:db8::1");
assert_eq!(addr_spec.is_literal(), true);
assert_eq!(addr_spec.to_string(), "test@[IPv6:2001:db8::1]");

You can also create an address specification from its parts:

use addr_spec::AddrSpec;

let addr_spec = AddrSpec::new("test".to_string(), "example.com".to_string());
assert_eq!(addr_spec.local_part(), "test");
assert_eq!(addr_spec.domain(), "example.com");
assert_eq!(addr_spec.is_literal(), false);
assert_eq!(addr_spec.to_string(), "test@example.com");

If you want to just normalize an address, you can use the normalize function:

use addr_spec::AddrSpec;

assert_eq!(
    &AddrSpec::normalize("\"test\"@example.com").unwrap(),
    "test@example.com"
);

References

• RFC 5322
• RFC 6531
• RFC 6532

Implementations

impl AddrSpec

pub fn normalize(address: &str) -> Result<String, ParseError>

Normalizes the address.

This is a convenience function that parses the address and then serializes it again.

It is equivalent to address.parse::<AddrSpec>()?.to_string().

Examples

use addr_spec::AddrSpec;

assert_eq!(
    &AddrSpec::normalize("\"test\"@example.com").unwrap(),
    "test@example.com"
);

pub fn new(local_part: String, domain: String) -> Self

Creates a new address specification.

pub fn with_literal(local_part: String, domain: String) -> Self

Creates a new address specification with a literal domain.

pub fn local_part(&self) -> &str

Returns the local part of the address.

pub fn domain(&self) -> &str

Returns the domain of the address.

pub fn is_literal(&self) -> bool

Returns whether the domain is literal.

pub fn into_parts(self) -> (String, String)

Returns the local part and domain of the address.

pub fn into_parts_with_literal(self) -> (String, String, bool)

Returns the local part and domain of the address.

pub fn is_valid(&self) -> bool

Returns whether the address specification is valid.

pub fn is_local_part_valid(&self) -> Option<usize>

Returns the index of the first invalid character in the local part.

pub fn is_domain_valid(&self) -> Option<usize>

Returns the index of the first invalid character in the domain.

Trait Implementations

impl Clone for AddrSpec

fn clone(&self) -> AddrSpec

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AddrSpec

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

Formats the value using the given formatter.

impl FromStr for AddrSpec

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl Hash for AddrSpec

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 AddrSpec

fn cmp(&self, other: &AddrSpec) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<AddrSpec> for AddrSpec

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<AddrSpec> for AddrSpec

fn partial_cmp(&self, other: &AddrSpec) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl ToString for AddrSpec

fn to_string(&self) -> String

Converts the given value to a String.

impl Eq for AddrSpec

impl StructuralEq for AddrSpec

impl StructuralPartialEq for AddrSpec