Struct MimeMessage

pub struct MimeMessage {
    pub headers: HeaderMap,
    pub body: String,
    pub message_type: Option<MimeMultipartType>,
    pub message_type_params: Option<HashMap<String, String>>,
    pub children: Vec<MimeMessage>,
    pub boundary: String,
}

Represents a MIME message [unstable]

Fields

headers: HeaderMap

The headers for this message

body: String

The content of this message

Keep in mind that this is the undecoded form, so may be quoted-printable or base64 encoded.

message_type: Option<MimeMultipartType>

The MIME multipart message type of this message, or None if the message is not a multipart message.

message_type_params: Option<HashMap<String, String>>

Any additional parameters of the MIME multipart header, not including the boundary.

children: Vec<MimeMessage>

The sub-messages of this message

boundary: String

The boundary used for MIME multipart messages

This will always be set, even if the message only has a single part

Implementations

impl MimeMessage

pub fn new(body: String) -> MimeMessage

[unstable]

Examples found in repository

examples/printing.rs (line 7)

fn main() {
    let parts = vec![
        MimeMessage::new("First part".to_string()),
        MimeMessage::new("Second part".to_string()),
    ];

    let mut message = MimeMessage::new("Parent".to_string());

    for part in parts.into_iter() {
        message.children.push(part);
    }

    message.headers.insert(
        Header::new_with_value(
            "To".to_string(),
            vec![
                Address::new_mailbox_with_name(
                    "John Doe".to_string(),
                    "john@example.org".to_string(),
                ),
                Address::new_mailbox_with_name(
                    "Joe Blogs".to_string(),
                    "joe@example.org".to_string(),
                ),
                Address::new_mailbox_with_name(
                    "Mr Black".to_string(),
                    "mafia_black@example.org".to_string(),
                ),
            ],
        )
        .unwrap(),
    );

    message.update_headers();

    println!("{}", message.as_string());
}

pub fn new_with_children( body: String, message_type: MimeMultipartType, children: Vec<MimeMessage>, ) -> MimeMessage

pub fn new_with_boundary( body: String, message_type: MimeMultipartType, children: Vec<MimeMessage>, boundary: String, ) -> MimeMessage

pub fn new_with_boundary_and_params( body: String, message_type: MimeMultipartType, children: Vec<MimeMessage>, boundary: String, message_type_params: Option<HashMap<String, String>>, ) -> MimeMessage

pub fn new_blank_message() -> MimeMessage

pub fn update_headers(&mut self)

Update the headers on this message based on the internal state.

When certain properties of the message are modified, the headers used to represent them are not automatically updated. Call this if these are changed.

Examples found in repository

examples/printing.rs (line 38)

fn main() {
    let parts = vec![
        MimeMessage::new("First part".to_string()),
        MimeMessage::new("Second part".to_string()),
    ];

    let mut message = MimeMessage::new("Parent".to_string());

    for part in parts.into_iter() {
        message.children.push(part);
    }

    message.headers.insert(
        Header::new_with_value(
            "To".to_string(),
            vec![
                Address::new_mailbox_with_name(
                    "John Doe".to_string(),
                    "john@example.org".to_string(),
                ),
                Address::new_mailbox_with_name(
                    "Joe Blogs".to_string(),
                    "joe@example.org".to_string(),
                ),
                Address::new_mailbox_with_name(
                    "Mr Black".to_string(),
                    "mafia_black@example.org".to_string(),
                ),
            ],
        )
        .unwrap(),
    );

    message.update_headers();

    println!("{}", message.as_string());
}

pub fn parse(s: &str) -> ParsingResult<MimeMessage>

Parse s into a MimeMessage.

Recurses down into each message, supporting an unlimited depth of messages.

Be warned that each sub-message that fails to be parsed will be thrown away. [unstable]

Examples found in repository

examples/parse_email.rs (line 25)

fn main() {
    let args: Vec<_> = env::args().collect();
    assert!(args.len() > 1);
    let msg_path = Path::new(&args[1]);

    let mut file = File::open(&msg_path).expect("can't open file");
    let raw_msg_bytes = {
        let mut rv: Vec<u8> = vec![];
        file.read_to_end(&mut rv).expect("can't read from file");
        rv
    };
    let raw_msg = String::from_utf8_lossy(&raw_msg_bytes);

    println!("INPUT:");
    println!("{}", &raw_msg);

    let msg = MimeMessage::parse(&raw_msg[..]).unwrap();

    println!("PARSED:");
    println!("{}", msg.as_string());
}

pub fn as_string(&self) -> String

Examples found in repository

examples/parse_email.rs (line 28)

fn main() {
    let args: Vec<_> = env::args().collect();
    assert!(args.len() > 1);
    let msg_path = Path::new(&args[1]);

    let mut file = File::open(&msg_path).expect("can't open file");
    let raw_msg_bytes = {
        let mut rv: Vec<u8> = vec![];
        file.read_to_end(&mut rv).expect("can't read from file");
        rv
    };
    let raw_msg = String::from_utf8_lossy(&raw_msg_bytes);

    println!("INPUT:");
    println!("{}", &raw_msg);

    let msg = MimeMessage::parse(&raw_msg[..]).unwrap();

    println!("PARSED:");
    println!("{}", msg.as_string());
}

examples/printing.rs (line 40)

fn main() {
    let parts = vec![
        MimeMessage::new("First part".to_string()),
        MimeMessage::new("Second part".to_string()),
    ];

    let mut message = MimeMessage::new("Parent".to_string());

    for part in parts.into_iter() {
        message.children.push(part);
    }

    message.headers.insert(
        Header::new_with_value(
            "To".to_string(),
            vec![
                Address::new_mailbox_with_name(
                    "John Doe".to_string(),
                    "john@example.org".to_string(),
                ),
                Address::new_mailbox_with_name(
                    "Joe Blogs".to_string(),
                    "joe@example.org".to_string(),
                ),
                Address::new_mailbox_with_name(
                    "Mr Black".to_string(),
                    "mafia_black@example.org".to_string(),
                ),
            ],
        )
        .unwrap(),
    );

    message.update_headers();

    println!("{}", message.as_string());
}

pub fn as_string_without_headers(&self) -> String

pub fn decoded_body_bytes(&self) -> Option<Vec<u8>>

Decode the body of this message, as a series of bytes

pub fn decoded_body_string(&self) -> ParsingResult<String>

Decode the body of this message, as a string.

This takes into account any charset as set on the Content-Type header, decoding the bytes with this character set.

Trait Implementations

impl Clone for MimeMessage

fn clone(&self) -> MimeMessage

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MimeMessage

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

Formats the value using the given formatter.

impl PartialEq for MimeMessage

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

impl StructuralPartialEq for MimeMessage