Enum email_address_list::Contact

pub enum Contact {
    Email(EmailContact),
    Garbage(GarbageContact),
}

Either an EmailContact we could successfully parse or a GarbageContact we didn’t want to throw away

Variants

Email(EmailContact)

Garbage(GarbageContact)

Implementations

impl Contact

pub fn is_garbage(&self) -> bool

Trait Implementations

impl Clone for Contact

fn clone(&self) -> Contact

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Contactish for Contact

Will be handed down on our variants’ contents, which implement the same trait

The exception to the rule is the ::new method.

Please note: the current implementation does not (yet?) magically change a Contact::Garbage variant into a Contact::Email one if you try to call ::set_email. It merely returns an unchanged Self.

fn new<T>(email: T) -> Selfwhere
    T: AsRef<str>,

By default we create a new Contact::Email variant, since Contact::Garbage is merely a fallback

fn name(&self) -> Option<&String>

fn email(&self) -> Option<&String>

fn comment(&self) -> Option<&String>

fn set_name<T>(self, name: T) -> Selfwhere
    T: AsRef<str>,

fn set_comment<T>(self, comment: T) -> Selfwhere
    T: AsRef<str>,

fn set_email<T>(self, email: T) -> Selfwhere
    T: AsRef<str>,

impl Debug for Contact

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

Formats the value using the given formatter.

impl DeepEq<Contact> for Contact

fn deep_eq(&self, other: &Contact) -> bool

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

impl From<EmailContact> for Contact

fn from(contact: EmailContact) -> Contact

Converts to this type from the input type.

impl From<GarbageContact> for Contact

fn from(garbage: GarbageContact) -> Contact

Converts to this type from the input type.

impl PartialEq<Contact> for Contact

fn eq(&self, other: &Contact) -> 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.