Struct email_address_parser::EmailAddress

pub struct EmailAddress { /* private fields */ }

Email address struct.

Examples

use email_address_parser::EmailAddress;

assert!(EmailAddress::parse("foo@-bar.com", None).is_none());
let email = EmailAddress::parse("foo@bar.com", None);
assert!(email.is_some());
let email = email.unwrap();
assert_eq!(email.get_local_part(), "foo");
assert_eq!(email.get_domain(), "bar.com");
assert_eq!(format!("{}", email), "foo@bar.com");

Implementations

impl EmailAddress

pub fn parse( input: &str, options: Option<ParsingOptions> ) -> Option<EmailAddress>

Parses a given string as an email address.

Accessible from WASM.

Returns Some(EmailAddress) if the parsing is successful, else None.

Examples

use email_address_parser::*;

// strict parsing
let email = EmailAddress::parse("foo@bar.com", None);
assert!(email.is_some());
let email = email.unwrap();
assert_eq!(email.get_local_part(), "foo");
assert_eq!(email.get_domain(), "bar.com");

// non-strict parsing
let email = EmailAddress::parse("\u{0d}\u{0a} \u{0d}\u{0a} test@iana.org", Some(ParsingOptions::new(true)));
assert!(email.is_some());

// parsing invalid address
let email = EmailAddress::parse("test@-iana.org", Some(ParsingOptions::new(true)));
assert!(email.is_none());
let email = EmailAddress::parse("test@-iana.org", Some(ParsingOptions::new(true)));
assert!(email.is_none());
let email = EmailAddress::parse("test", Some(ParsingOptions::new(true)));
assert!(email.is_none());
let email = EmailAddress::parse("test", Some(ParsingOptions::new(true)));
assert!(email.is_none());

pub fn is_valid(input: &str, options: Option<ParsingOptions>) -> bool

Validates if the given input string is an email address or not.

Returns true if the input is valid, false otherwise. Unlike the parse method, it does not instantiate an EmailAddress.

Examples

use email_address_parser::*;

// strict validation
assert!(EmailAddress::is_valid("foo@bar.com", None));

// non-strict validation
assert!(EmailAddress::is_valid("\u{0d}\u{0a} \u{0d}\u{0a} test@iana.org", Some(ParsingOptions::new(true))));

// invalid address
assert!(!EmailAddress::is_valid("test@-iana.org", Some(ParsingOptions::new(true))));
assert!(!EmailAddress::is_valid("test@-iana.org", Some(ParsingOptions::new(true))));
assert!(!EmailAddress::is_valid("test", Some(ParsingOptions::new(true))));
assert!(!EmailAddress::is_valid("test", Some(ParsingOptions::new(true))));

impl EmailAddress

pub fn new( local_part: &str, domain: &str, options: Option<ParsingOptions> ) -> Result<EmailAddress, String>

Instantiates a new Some(EmailAddress) for a valid local part and domain. Returns Err otherwise.

Examples

use email_address_parser::EmailAddress;

let email = EmailAddress::new("foo", "bar.com", None).unwrap();

assert_eq!(EmailAddress::new("foo", "-bar.com", None).is_err(), true);

pub fn get_local_part(&self) -> &str

Returns the local part of the email address.

Not accessible from WASM.

Examples

use email_address_parser::EmailAddress;

let email = EmailAddress::new("foo", "bar.com", None).unwrap();
assert_eq!(email.get_local_part(), "foo");

let email = EmailAddress::parse("foo@bar.com", None).unwrap();
assert_eq!(email.get_local_part(), "foo");

pub fn get_domain(&self) -> &str

Returns the domain of the email address.

Not accessible from WASM.

Examples

use email_address_parser::EmailAddress;

let email = EmailAddress::new("foo", "bar.com", None).unwrap();
assert_eq!(email.get_domain(), "bar.com");

let email = EmailAddress::parse("foo@bar.com", None).unwrap();
assert_eq!(email.get_domain(), "bar.com");

Trait Implementations

impl Clone for EmailAddress

fn clone(&self) -> EmailAddress

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EmailAddress

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

Formats the value using the given formatter.

impl Display for EmailAddress

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

Formats the value using the given formatter.

impl FromStr for EmailAddress

Allows conversion from string slices (&str) to EmailAddress using the FromStr trait. This wraps around EmailAddress::parse using the default ParsingOptions.

Examples

use email_address_parser::EmailAddress;
use std::str::FromStr;

const input_address : &str = "string@slice.com";

let myaddr : EmailAddress = input_address.parse().expect("could not parse str into EmailAddress");
let myotheraddr = EmailAddress::from_str(input_address).expect("could create EmailAddress from str");

assert_eq!(myaddr, myotheraddr);

type Err = Error

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 EmailAddress

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<EmailAddress> for EmailAddress

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

impl StructuralEq for EmailAddress

impl StructuralPartialEq for EmailAddress