Enum melib::email::address::Address

pub enum Address {
    Mailbox(MailboxAddress),
    Group(GroupAddress),
}

An email address.

Conforms to RFC5322 - Internet Message Format.

Creating an Address

You can directly create an address with Address::new,

let addr = Address::new(
    Some("Jörg Doe".to_string()),
    "joerg@example.com".to_string(),
);
assert_eq!(addr.to_string().as_str(), "Jörg Doe <joerg@example.com>");

or parse it from a raw value:

let (rest_bytes, addr) = melib::email::parser::address::address(
    "=?utf-8?q?J=C3=B6rg_Doe?= <joerg@example.com>".as_bytes(),
)
.unwrap();
assert!(rest_bytes.is_empty());
assert_eq!(addr.get_display_name(), Some("Jörg Doe".to_string()));
assert_eq!(addr.get_email(), "joerg@example.com".to_string());

Variants

Mailbox(MailboxAddress)

Group(GroupAddress)

Implementations

impl Address

pub fn new(display_name: Option<String>, address: String) -> Self

pub fn new_group(display_name: String, mailbox_list: Vec<Self>) -> Self

pub fn raw(&self) -> &[u8]

pub fn get_display_name(&self) -> Option<String>

Get the display name of this address.

If it’s a group, it’s the name of the group. Otherwise it’s the display_name part of the mailbox:

          raw                         raw
┌──────────┴────────────┐   ┌──────────┴────────────────────┐
Name <address@domain.tld>   "Name Name2" <address@domain.tld>
└─┬┘  └──────────┬─────┘     └─────┬──┘   └──────────┬─────┘
display_name     │          display_name             │
                 │                                   │
           address_spec                        address_spec

pub fn get_email(&self) -> String

Get the address spec part of this address. A group returns an empty String.

pub fn address_spec_raw(&self) -> &[u8]

pub fn get_fqdn(&self) -> Option<String>

pub fn get_tags(&self, separator: char) -> Vec<String>

pub fn list_try_from<T: AsRef<[u8]>>(val: T) -> Result<Vec<Self>>

pub fn contains_address(&self, other: &Self) -> bool

pub fn subaddress(&self, separator: &str) -> Option<(Self, String)>

Get subaddress out of an address (e.g. ken+subaddress@example.org).

Subaddresses are commonly text following a “+” character in an email address’s local part . They are defined in RFC5233 Sieve Email Filtering: Subaddress Extension

Examples

let addr = "ken+sieve@example.org";
let (rest, val) = melib::email::parser::address::address(addr.as_bytes()).unwrap();
assert!(rest.is_empty());
assert_eq!(
    val.subaddress("+"),
    Some((
        Address::new(None, "ken@example.org".to_string()),
        "sieve".to_string()
    ))
);

pub fn display_name_bytes(&self) -> &[u8]

Get the display name of this address in bytes.

For a string, see the display_name method.

pub fn display(&self) -> UIAddress<'_>

Returns a type that prints addresses suitably for UI display, e.g. without quotes.

Example

let addr = Address::new(
    Some("Jörg T. Doe".to_string()),
    "joerg@example.com".to_string(),
);
assert_eq!(
    addr.to_string().as_str(),
    r#""Jörg T. Doe" <joerg@example.com>"#
);
assert_eq!(
    addr.display().to_string().as_str(),
    "Jörg T. Doe <joerg@example.com>"
);

pub fn display_name(&self) -> UINameAddress<'_>

Returns a type that prints the names of addresses (or the e-mail part, if the name is missing) suitably for UI display, e.g. without quotes.

Example

let addr = Address::new(
    Some("Jörg T. Doe".to_string()),
    "joerg@example.com".to_string(),
);
assert_eq!(
    addr.to_string().as_str(),
    r#""Jörg T. Doe" <joerg@example.com>"#
);
assert_eq!(addr.display_name().to_string().as_str(), "Jörg T. Doe");

pub fn display_slice(slice: &[Self]) -> String

Formats a slice of Addresses with their Address::display method, separated by comma or separator if passed.

pub fn display_name_slice(slice: &[Self]) -> String

Formats a slice of Addresses with their Address::display_name method, separated by comma or separator if passed.

Trait Implementations

impl Clone for Address

fn clone(&self) -> Address

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Address

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Address

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Address

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

Formats the value using the given formatter.

impl Hash for Address

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 PartialEq for Address

fn eq(&self, other: &Self) -> 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 Serialize for Address

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 Address

type Error = Error

The type returned in the event of a conversion error.

fn try_from(val: &str) -> Result<Self>

Performs the conversion.

impl Eq for Address