Struct melib::email::Envelope

pub struct Envelope {

    pub hash: EnvelopeHash,
    pub date: String,
    pub timestamp: UnixTimestamp,
    pub from: SmallVec<[Address; 1]>,
    pub to: SmallVec<[Address; 1]>,
    pub cc: SmallVec<[Address; 1]>,
    pub bcc: Vec<Address>,
    pub subject: Option<String>,
    pub message_id: MessageID,
    pub in_reply_to: Option<MessageID>,
    pub references: Option<References>,
    pub other_headers: HeaderMap,
    pub thread: ThreadNodeHash,
    pub flags: Flag,
    pub has_attachments: bool,
    pub labels: SmallVec<[u64; 8]>,
}

Envelope represents all the header and structure data of an email we need to know.

Attachments (the email’s body) is parsed on demand with body method.

To access the email attachments, you need to parse them from the raw email bytes into an Attachment object.

Fields

hash: EnvelopeHash

date: String

timestamp: UnixTimestamp

from: SmallVec<[Address; 1]>

to: SmallVec<[Address; 1]>

cc: SmallVec<[Address; 1]>

bcc: Vec<Address>

subject: Option<String>

message_id: MessageID

in_reply_to: Option<MessageID>

references: Option<References>

other_headers: HeaderMap

thread: ThreadNodeHash

flags: Flag

has_attachments: bool

labels: SmallVec<[u64; 8]>

Implementations

impl Envelope

pub fn new(hash: EnvelopeHash) -> Self

pub fn set_hash(&mut self, new_hash: EnvelopeHash) -> &mut Self

pub fn from_bytes(bytes: &[u8], flags: Option<Flag>) -> Result<Envelope>

pub fn hash(&self) -> EnvelopeHash

pub fn populate_headers(&mut self, bytes: &[u8]) -> Result<()>

pub fn date(&self) -> UnixTimestamp

pub fn datetime(&self) -> UnixTimestamp

pub fn date_as_str(&self) -> &str

pub fn from(&self) -> &[Address]

pub fn field_bcc_to_string(&self) -> String

pub fn field_cc_to_string(&self) -> String

pub fn field_from_to_string(&self) -> String

pub fn to(&self) -> &[Address]

pub fn cc(&self) -> &[Address]

pub fn bcc(&self) -> &[Address]

pub fn field_to_to_string(&self) -> String

pub fn field_references_to_string(&self) -> String

pub fn body_bytes(&self, bytes: &[u8]) -> Attachment

pub fn headers<'a>(&self, bytes: &'a [u8]) -> Result<Vec<(&'a str, &'a str)>>

pub fn subject(&self) -> Cow<'_, str>

pub fn in_reply_to(&self) -> Option<&MessageID>

pub fn in_reply_to_display(&self) -> Option<Cow<'_, str>>

pub fn in_reply_to_raw(&self) -> Option<Cow<'_, str>>

pub fn message_id(&self) -> &MessageID

pub fn message_id_display(&self) -> Cow<'_, str>

pub fn message_id_raw(&self) -> Cow<'_, str>

pub fn set_date(&mut self, new_val: &[u8]) -> &mut Self

pub fn set_bcc(&mut self, new_val: Vec<Address>) -> &mut Self

pub fn set_cc(&mut self, new_val: SmallVec<[Address; 1]>) -> &mut Self

pub fn set_from(&mut self, new_val: SmallVec<[Address; 1]>) -> &mut Self

pub fn set_to(&mut self, new_val: SmallVec<[Address; 1]>) -> &mut Self

pub fn set_in_reply_to(&mut self, new_val: &[u8]) -> &mut Self

pub fn set_subject(&mut self, new_val: Vec<u8>) -> &mut Self

pub fn set_message_id(&mut self, new_val: &[u8]) -> &mut Self

pub fn push_references(&mut self, new_ref: MessageID)

pub fn set_references(&mut self, new_val: &[u8]) -> &mut Self

pub fn references(&self) -> SmallVec<[&MessageID; 8]>

pub fn other_headers(&self) -> &HeaderMap

pub fn other_headers_mut(&mut self) -> &mut HeaderMap

pub fn thread(&self) -> ThreadNodeHash

pub fn set_thread(&mut self, new_val: ThreadNodeHash) -> &mut Self

pub fn set_datetime(&mut self, new_val: UnixTimestamp) -> &mut Self

pub fn set_flag(&mut self, f: Flag, value: bool) -> &mut Self

pub fn set_flags(&mut self, f: Flag) -> &mut Self

pub fn flags(&self) -> Flag

pub fn set_seen(&mut self) -> &mut Self

pub fn set_unseen(&mut self) -> &mut Self

pub fn is_seen(&self) -> bool

pub fn set_has_attachments(&mut self, new_val: bool) -> &mut Self

pub fn has_attachments(&self) -> bool

pub fn labels(&self) -> &SmallVec<[u64; 8]>

pub fn labels_mut(&mut self) -> &mut SmallVec<[u64; 8]>

Trait Implementations

impl Clone for Envelope

fn clone(&self) -> Envelope

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Envelope

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

Formats the value using the given formatter.

impl Default for Envelope

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Envelope

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl FromSql for Envelope

fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self>

Converts SQLite value into Rust value.

impl Ord for Envelope

fn cmp(&self, other: &Envelope) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Envelope> for Envelope

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

impl PartialOrd<Envelope> for Envelope

fn partial_cmp(&self, other: &Envelope) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl QueryTrait for Envelope

fn is_match(&self, query: &Query) -> bool

impl Serialize for Envelope

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl ToSql for Envelope

fn to_sql(&self) -> Result<ToSqlOutput<'_>>

Converts Rust value to SQLite value

impl Eq for Envelope