Enum imap_types::response::data::FetchAttributeValue

pub enum FetchAttributeValue<'a> {
    Body(BodyStructure<'a>),
    BodyExt {
        section: Option<Section<'a>>,
        origin: Option<u32>,
        data: NString<'a>,
    },
    BodyStructure(BodyStructure<'a>),
    Envelope(Envelope<'a>),
    Flags(Vec<Flag<'a>>),
    InternalDate(MyDateTime),
    Rfc822(NString<'a>),
    Rfc822Header(NString<'a>),
    Rfc822Size(u32),
    Rfc822Text(NString<'a>),
    Uid(NonZeroU32),
}

The current data items are:

Variants

Body(BodyStructure<'a>)

A form of BODYSTRUCTURE without extension data.

BODY

BodyExt

Fields

section: Option<Section<'a>>

origin: Option<u32>

data: NString<'a>

A string expressing the body contents of the specified section. The string SHOULD be interpreted by the client according to the content transfer encoding, body type, and subtype.

If the origin octet is specified, this string is a substring of the entire body contents, starting at that origin octet. This means that BODY[]<0> MAY be truncated, but BODY[] is NEVER truncated.

Note: The origin octet facility MUST NOT be used by a server in a FETCH response unless the client specifically requested it by means of a FETCH of a BODY[

]<> data item.

8-bit textual data is permitted if a [CHARSET] identifier is part of the body parameter parenthesized list for this section. Note that headers (part specifiers HEADER or MIME, or the header portion of a MESSAGE/RFC822 part), MUST be 7-bit; 8-bit characters are not permitted in headers. Note also that the [RFC-2822] delimiting blank line between the header and the body is not affected by header line subsetting; the blank line is always included as part of header data, except in the case of a message which has no body and no blank line.

Non-textual data such as binary data MUST be transfer encoded into a textual form, such as BASE64, prior to being sent to the client. To derive the original binary data, the client MUST decode the transfer encoded string.

BODY[<section>]<<origin octet>>

BodyStructure(BodyStructure<'a>)

A parenthesized list that describes the [MIME-IMB] body structure of a message. This is computed by the server by parsing the [MIME-IMB] header fields, defaulting various fields as necessary.

BODYSTRUCTURE

Envelope(Envelope<'a>)

A parenthesized list that describes the envelope structure of a message. This is computed by the server by parsing the [RFC-2822] header into the component parts, defaulting various fields as necessary.

ENVELOPE

Flags(Vec<Flag<'a>>)

A parenthesized list of flags that are set for this message.

FLAGS

InternalDate(MyDateTime)

A string representing the internal date of the message.

INTERNALDATE

Rfc822(NString<'a>)

Equivalent to BODY[].

RFC822

Rfc822Header(NString<'a>)

Equivalent to BODY[HEADER]. Note that this did not result in \Seen being set, because RFC822.HEADER response data occurs as a result of a FETCH of RFC822.HEADER. BODY[HEADER] response data occurs as a result of a FETCH of BODY[HEADER] (which sets \Seen) or BODY.PEEK[HEADER] (which does not set \Seen).

RFC822.HEADER

Rfc822Size(u32)

A number expressing the [RFC-2822] size of the message.

RFC822.SIZE

Rfc822Text(NString<'a>)

Equivalent to BODY[TEXT].

RFC822.TEXT

Uid(NonZeroU32)

A number expressing the unique identifier of the message.

UID

Trait Implementations

impl<'a> Clone for FetchAttributeValue<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for FetchAttributeValue<'a>

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

Formats the value using the given formatter.

impl<'a> Encode for FetchAttributeValue<'a>

fn encode(&self, writer: &mut impl Write) -> Result<()>

impl<'a> Hash for FetchAttributeValue<'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, 

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq<FetchAttributeValue<'a>> for FetchAttributeValue<'a>

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &FetchAttributeValue<'a>) -> bool

This method tests for !=.

impl<'a> Eq for FetchAttributeValue<'a>

impl<'a> StructuralEq for FetchAttributeValue<'a>

impl<'a> StructuralPartialEq for FetchAttributeValue<'a>