Enum imap_types::body::BodyStructure

pub enum BodyStructure<'a> {
    Single {
        body: Body<'a>,
        extension_data: Option<SinglePartExtensionData<'a>>,
    },
    Multi {
        bodies: NonEmptyVec<BodyStructure<'a>>,
        subtype: IString<'a>,
        extension_data: Option<MultiPartExtensionData<'a>>,
    },
}

The BODY(STRUCTURE).

Variants

Single

Fields

body: Body<'a>

Inner body.

extension_data: Option<SinglePartExtensionData<'a>>

Extension data

Extension data is never returned with the BODY fetch, but can be returned with a BODYSTRUCTURE fetch. Extension data, if present, MUST be in the defined order.

Any following extension data are not yet defined in this version of the protocol, and would be as described above under multipart extension data.

For example, a simple text message of 48 lines and 2279 octets can have a body structure of:

("TEXT" "PLAIN" ("CHARSET" "US-ASCII") NIL NIL "7BIT" 2279 48)

Multi

Fields

bodies: NonEmptyVec<BodyStructure<'a>>

Inner bodies.

subtype: IString<'a>

Subtype.

extension_data: Option<MultiPartExtensionData<'a>>

Extension data.

Multiple parts are indicated by parenthesis nesting. Instead of a body type as the first element of the parenthesized list, there is a sequence of one or more nested body structures. The second (last?!) element of the parenthesized list is the multipart subtype (mixed, digest, parallel, alternative, etc.).

For example, a two part message consisting of a text and a BASE64-encoded text attachment can have a body structure of:

(
    ("TEXT" "PLAIN" ("CHARSET" "US-ASCII") NIL NIL "7BIT" 1152 23)
    ("TEXT" "PLAIN" ("CHARSET" "US-ASCII" "NAME" "cc.diff") "<960723163407.20117h@cac.washington.edu>" "Compiler diff" "BASE64" 4554 73)
    "MIXED"
)

Extension data follows the multipart subtype. Extension data is never returned with the BODY fetch, but can be returned with a BODYSTRUCTURE fetch. Extension data, if present, MUST be in the defined order.

See ExtensionMultiPartData.

Any following extension data are not yet defined in this version of the protocol. Such extension data can consist of zero or more NILs, strings, numbers, or potentially nested parenthesized lists of such data. Client implementations that do a BODYSTRUCTURE fetch MUST be prepared to accept such extension data. Server implementations MUST NOT send such extension data until it has been defined by a revision of this protocol.

Example (not in RFC)

Multipart/mixed is represented as follows…

(
    ("text" "html" ("charset" "us-ascii") NIL NIL "7bit" 28 0 NIL NIL NIL NIL)
    ("text" "plain" ("charset" "us-ascii") NIL NIL "7bit" 11 0 NIL NIL NIL NIL)
    "mixed" ("boundary" "xxx") NIL NIL NIL
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
            |
            | extension data
)

Trait Implementations

impl<'a> Arbitrary<'a> for BodyStructure<'a>

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<'a> Clone for BodyStructure<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for BodyStructure<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for BodyStructure<'a>

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

Deserialize this value from the given Serde deserializer.

impl<'a> Hash for BodyStructure<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> IntoBoundedStatic for BodyStructure<'a>

type Static = BodyStructure<'static>

The target type is bounded by the 'static lifetime.

fn into_static(self) -> Self::Static

Convert an owned T into an owned T such that T: 'static.

impl<'a> PartialEq<BodyStructure<'a>> for BodyStructure<'a>

fn eq(&self, other: &BodyStructure<'a>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for BodyStructure<'a>

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

Serialize this value into the given Serde serializer.

impl<'a> ToBoundedStatic for BodyStructure<'a>

type Static = BodyStructure<'static>

The target type is bounded by the 'static lifetime.

fn to_static(&self) -> Self::Static

Convert an &T to an owned T such that T: 'static.

impl<'a> Eq for BodyStructure<'a>

impl<'a> StructuralEq for BodyStructure<'a>

impl<'a> StructuralPartialEq for BodyStructure<'a>