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<Address>) -> 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(val: &str) -> Result<Vec<Address>>

pub fn contains_address(&self, other: &Address) -> 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()
    ))
);

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

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, 

Feeds a slice of this type into the given Hasher.

impl Into<Address> for EmailAddress

fn into(self) -> Address

Performs the conversion.

impl PartialEq<Address> for Address

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

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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 = MeliError

The type returned in the event of a conversion error.

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

Performs the conversion.