Struct email_format::Email

pub struct Email { /* private fields */ }

Implementations

impl Email

pub fn new<F, D>(from: F, date: D) -> Result<Email, ParseError> where
    From: TryFrom<F, Error = ParseError>,
    OrigDate: TryFrom<D, Error = ParseError>, 

Create a new email structure. The From address and Date fields are required in all valid emails, thus you must pass these in.

pub fn set_date<D>(&mut self, date: D) -> Result<(), ParseError> where
    OrigDate: TryFrom<D, Error = ParseError>, 

Replace the Date field in the email

pub fn get_date(&self) -> OrigDate

Fetch the Date field from the email

pub fn set_from<F>(&mut self, from: F) -> Result<(), ParseError> where
    From: TryFrom<F, Error = ParseError>, 

Replace the From field in the email

pub fn get_from(&self) -> From

Fetch the From field from the email

pub fn set_sender<S>(&mut self, sender: S) -> Result<(), ParseError> where
    Sender: TryFrom<S, Error = ParseError>, 

Set or replace the Sender field in the email

pub fn get_sender(&self) -> Option<Sender>

Fetch the Sender field from the email

pub fn clear_sender(&mut self)

Remove the Sender field from the email

pub fn set_reply_to<R>(&mut self, reply_to: R) -> Result<(), ParseError> where
    ReplyTo: TryFrom<R, Error = ParseError>, 

Set or replace the Reply-To field in the email

pub fn get_reply_to(&self) -> Option<ReplyTo>

Fetch the Reply-To field from the email

pub fn clear_reply_to(&mut self)

Remove the Reply-To field from the email

pub fn set_to<T>(&mut self, to: T) -> Result<(), ParseError> where
    To: TryFrom<T, Error = ParseError>, 

Set or replace the To field in the email

pub fn get_to(&self) -> Option<To>

Fetch the To field from the email

pub fn clear_to(&mut self)

Remove the To field from the email

pub fn set_cc<C>(&mut self, cc: C) -> Result<(), ParseError> where
    Cc: TryFrom<C, Error = ParseError>, 

Set or replace the Cc field in the email

pub fn get_cc(&self) -> Option<Cc>

Fetch the Cc field from the email

pub fn clear_cc(&mut self)

Remove the Cc field from the email

pub fn set_bcc<B>(&mut self, bcc: B) -> Result<(), ParseError> where
    Bcc: TryFrom<B, Error = ParseError>, 

Set or replace the Bcc field in the email

pub fn get_bcc(&self) -> Option<Bcc>

Fetch the Bcc field from the email

pub fn clear_bcc(&mut self)

Remove the Bcc field from the email

pub fn set_message_id<M>(&mut self, message_id: M) -> Result<(), ParseError> where
    MessageId: TryFrom<M, Error = ParseError>, 

Set or replace the Message-ID field in the email

pub fn get_message_id(&self) -> Option<MessageId>

Fetch the Message-ID field from the email

pub fn clear_message_id(&mut self)

Remove the Message-ID field from the email

pub fn set_in_reply_to<I>(&mut self, in_reply_to: I) -> Result<(), ParseError> where
    InReplyTo: TryFrom<I, Error = ParseError>, 

Set or replace the In-Reply-To field in the email

pub fn get_in_reply_to(&self) -> Option<InReplyTo>

Fetch the In-Reply-To field from the email

pub fn clear_in_reply_to(&mut self)

Remove the In-Reply-To field from the email

pub fn set_references<R>(&mut self, references: R) -> Result<(), ParseError> where
    References: TryFrom<R, Error = ParseError>, 

Set or replace the References field in the email

pub fn get_references(&self) -> Option<References>

Fetch the References field from the email

pub fn clear_references(&mut self)

Remove the References field from the email

pub fn set_subject<S>(&mut self, subject: S) -> Result<(), ParseError> where
    Subject: TryFrom<S, Error = ParseError>, 

Set or replace the Subject field in the email

pub fn get_subject(&self) -> Option<Subject>

Fetch the Subject field from the email

pub fn clear_subject(&mut self)

Remove the Subject field from the email

pub fn add_comments<C>(&mut self, comments: C) -> Result<(), ParseError> where
    Comments: TryFrom<C, Error = ParseError>, 

Add a Comments field in the email. This may be in addition to existing Comments fields.

pub fn get_comments(&self) -> Vec<Comments>

Fetch all Comments fields from the email

pub fn clear_comments(&mut self)

Remove all Comments fields from the email

pub fn add_keywords<K>(&mut self, keywords: K) -> Result<(), ParseError> where
    Keywords: TryFrom<K, Error = ParseError>, 

Add a Keywords field in the email. This may be in addition to existing Keywords fields.

pub fn get_keywords(&self) -> Vec<Keywords>

Fetch all Keywords fields from the email

pub fn clear_keywords(&mut self)

Remove all Keywords fields from the email

pub fn add_optional_field<O>(
    &mut self,
    optional_field: O
) -> Result<(), ParseError> where
    OptionalField: TryFrom<O, Error = ParseError>, 

Add an optional field to the email. This may be in addition to existing optional fields.

pub fn get_optional_fields(&self) -> Vec<OptionalField>

Fetch all optional fields from the email

pub fn clear_optional_fields(&mut self)

Clear all optional fields from the email

pub fn set_body<B>(&mut self, body: B) -> Result<(), ParseError> where
    Body: TryFrom<B, Error = ParseError>, 

Set or replace the Body in the email

pub fn get_body(&self) -> Option<Body>

Fetch the Body from the email

pub fn clear_body(&mut self)

Remove the Body from the email, leaving an empty body

pub fn as_bytes(&self) -> Vec<u8>

Stream the email into a byte vector and return that

pub fn as_string(&self) -> String

Stream the email into a byte vector, convert to a String, and return that

Trait Implementations

impl Clone for Email

fn clone(&self) -> Email

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Email

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

Formats the value using the given formatter.

impl Display for Email

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

Formats the value using the given formatter.

impl Parsable for Email

fn parse(input: &[u8]) -> Result<(Self, &[u8]), ParseError>

Parse the object off of the beginning of the input. If found, returns Some object, and a slice containing the remainer of the input.

impl Streamable for Email

fn stream<W: Write>(&self, w: &mut W) -> Result<usize, IoError>

Serializes and sends the content out to w, returning the number of bytes written.