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 to_owned(&self) -> MimePart<'static>

Obtain a version of self that has a static lifetime

pub fn deep_conformance_check(&self) -> MessageConformance

Recursively performs deeper conformance checks on the message. At this time that includes attempting to decode any text parts into UTF-8 to see if they are correctly annotated, but it may include more checks in the future. The results of the deep checks are combined with any conformance issues detected during parsing, and returned.

pub fn conformance(&self) -> MessageConformance

Returns the conformance flags determined during parsing

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 rfc2045_info(&self) -> Rfc2045Info

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

Decode transfer decoding and return the body

pub fn rebuild(&self, settings: Option<&CheckFixSettings>) -> 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, ) -> Result<()>

pub fn replace_binary_body( &mut self, content_type: &str, content: &[u8], ) -> Result<()>

pub fn new_no_transfer_encoding( content_type: &str, bytes: &[u8], ) -> Result<Self>

pub fn new_text(content_type: &str, content: &str) -> Result<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) -> Result<Self>

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

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

pub fn new_binary( content_type: &str, content: &[u8], options: Option<&AttachmentOptions>, ) -> Result<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.

pub fn check_fix_conformance( &self, check: MessageConformance, fix: MessageConformance, settings: CheckFixSettings, ) -> Result<Option<Self>>

Trait Implementations

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

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

Returns a duplicate 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>