Enum async_imap::types::Flag

pub enum Flag<'a> {
    Seen,
    Answered,
    Flagged,
    Deleted,
    Draft,
    Recent,
    MayCreate,
    Custom(Cow<'a, str>),
}

With the exception of Flag::Custom, these flags are system flags that are pre-defined in RFC 3501 section 2.3.2. All system flags begin with \ in the IMAP protocol. Certain system flags (\Deleted and \Seen) have special semantics described elsewhere.

A flag can be permanent or session-only on a per-flag basis. Permanent flags are those which the client can add or remove from the message flags permanently; that is, concurrent and subsequent sessions will see any change in permanent flags. Changes to session flags are valid only in that session.

Note: The \Recent system flag is a special case of a session flag. \Recent can not be used as an argument in a STORE or APPEND command, and thus can not be changed at all.

Variants

Seen

Message has been read

Answered

Message has been answered

Flagged

Message is “flagged” for urgent/special attention

Deleted

Message is “deleted” for removal by later EXPUNGE

Draft

Message has not completed composition (marked as a draft).

Recent

Message is “recently” arrived in this mailbox. This session is the first session to have been notified about this message; if the session is read-write, subsequent sessions will not see \Recent set for this message. This flag can not be altered by the client.

If it is not possible to determine whether or not this session is the first session to be notified about a message, then that message will generally be considered recent.

If multiple connections have the same mailbox selected simultaneously, it is undefined which of these connections will see newly-arrived messages with \Recent set and which will see it without \Recent set.

MayCreate

The Mailbox::permanent_flags can include this special flag (\*), which indicates that it is possible to create new keywords by attempting to store those flags in the mailbox.

Custom(Cow<'a, str>)

A non-standard user- or server-defined flag.

Trait Implementations

impl<'a> Clone for Flag<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Flag<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for Flag<'a>

fn from(s: &'a str) -> Self

Converts to this type from the input type.

impl<'a> From<String> for Flag<'a>

fn from(s: String) -> Self

Converts to this type from the input type.

impl<'a> Hash for Flag<'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> PartialEq for Flag<'a>

fn eq(&self, other: &Flag<'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> Eq for Flag<'a>

impl<'a> StructuralPartialEq for Flag<'a>