Struct MimePart

pub struct MimePart<'a> { /* private fields */ }

Implementations

impl<'a> MimePart<'a>

pub fn parse<S>(bytes: S) -> Result<Self>

where S: IntoSharedString<'a>,

Parse some data into a tree of MimeParts

pub fn conformance(&self) -> MessageConformance

pub fn child_parts(&self) -> &[Self]

Obtain a reference to the child parts

pub fn child_parts_mut(&mut self) -> &mut Vec<Self>

Obtain a mutable reference to the child parts

pub fn headers(&self) -> &HeaderMap<'_>

Obtains a reference to the headers

pub fn headers_mut<'b>(&'b mut self) -> &'b mut HeaderMap<'a>

Obtain a mutable reference to the headers

pub fn raw_body(&self) -> SharedString<'_>

Get the raw, transfer-encoded body

pub fn body(&self) -> Result<DecodedBody<'_>>

Decode transfer decoding and return the body

pub fn rebuild(&self) -> Result<Self>

Re-constitute the message. Each element will be parsed out, and the parsed form used to build a new message. This has the side effect of “fixing” non-conforming elements, but may come at the cost of “losing” the non-sensical or otherwise out of spec elements in the rebuilt message

pub fn write_message<W: Write>(&self, out: &mut W) -> Result<()>

Write the message content to the provided output stream

pub fn to_message_string(&self) -> String

Convenience method wrapping write_message that returns the formatted message as a standalone string

pub fn replace_text_body(&mut self, content_type: &str, content: &str)

pub fn new_text(content_type: &str, content: &str) -> Self

Constructs a new part with textual utf8 content. quoted-printable transfer encoding will be applied, unless it is smaller to represent the text in base64

pub fn new_text_plain(content: &str) -> Self

pub fn new_html(content: &str) -> Self

pub fn new_multipart( content_type: &str, parts: Vec<Self>, boundary: Option<&str>, ) -> Self

pub fn new_binary( content_type: &str, content: &[u8], options: Option<&AttachmentOptions>, ) -> Self

pub fn simplified_structure(&'a self) -> Result<SimplifiedStructure<'a>>

Returns a SimplifiedStructure representation of the mime tree, with the (probable) primary text/plain and text/html parts pulled out, and the remaining parts recorded as a flat attachments array

pub fn resolve_ptr(&self, ptr: PartPointer) -> Option<&Self>

Resolve a PartPointer to the corresponding MimePart

pub fn resolve_ptr_mut(&mut self, ptr: PartPointer) -> Option<&mut Self>

Resolve a PartPointer to the corresponding MimePart, for mutable access

pub fn simplified_structure_pointers( &self, ) -> Result<SimplifiedStructurePointers>

Returns a set of PartPointers that locate the (probable) primary text/plain and text/html parts, and the remaining parts recorded as a flat attachments array. The resulting PartPointers can be resolved to their actual instances for both immutable and mutable operations via resolve_ptr and resolve_ptr_mut.

Trait Implementations

impl<'a> Clone for MimePart<'a>

fn clone(&self) -> MimePart<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for MimePart<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for MimePart<'a>

fn eq(&self, other: &MimePart<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StructuralPartialEq for MimePart<'a>