Enum imap_types::response::Status

pub enum Status<'a> {
    Ok {
        tag: Option<Tag<'a>>,
        code: Option<Code<'a>>,
        text: Text<'a>,
    },
    No {
        tag: Option<Tag<'a>>,
        code: Option<Code<'a>>,
        text: Text<'a>,
    },
    Bad {
        tag: Option<Tag<'a>>,
        code: Option<Code<'a>>,
        text: Text<'a>,
    },
    Bye {
        code: Option<Code<'a>>,
        text: Text<'a>,
    },
}

7.1. Server Responses - Status Responses

Status responses are OK, NO, BAD, PREAUTH and BYE. OK, NO, and BAD can be tagged or untagged. PREAUTH and BYE are always untagged. Status responses MAY include an OPTIONAL “response code” (see Code.)

Note: Don’t use code: None and a text that starts with “[” as this would be ambiguous in IMAP.

Variants

Ok

Fields

tag: Option<Tag<'a>>

When tagged, it indicates successful completion of the associated command. The human-readable text MAY be presented to the user as an information message.

The untagged form indicates an information-only message; the nature of the information MAY be indicated by a response code.

The untagged form is also used as one of three possible greetings at connection startup. It indicates that the connection is not yet authenticated and that a LOGIN command is needed.

code: Option<Code<'a>>

Response code (optional)

text: Text<'a>

Human-readable text (must be at least 1 character!)

7.1.1. OK Response

The OK response indicates an information message from the server.

No

Fields

tag: Option<Tag<'a>>

When tagged, it indicates unsuccessful completion of the associated command. The untagged form indicates a warning; the command can still complete successfully.

code: Option<Code<'a>>

Response code (optional)

text: Text<'a>

The human-readable text describes the condition. (must be at least 1 character!)

7.1.2. NO Response

The NO response indicates an operational error message from the server.

Bad

Fields

tag: Option<Tag<'a>>

When tagged, it reports a protocol-level error in the client’s command; the tag indicates the command that caused the error. The untagged form indicates a protocol-level error for which the associated command can not be determined; it can also indicate an internal server failure.

code: Option<Code<'a>>

Response code (optional)

text: Text<'a>

The human-readable text describes the condition. (must be at least 1 character!)

7.1.3. BAD Response

The BAD response indicates an error message from the server.

Bye

Fields

code: Option<Code<'a>>

Response code (optional)

text: Text<'a>

The human-readable text MAY be displayed to the user in a status report by the client. (must be at least 1 character!)

7.1.5. BYE Response

The BYE response is always untagged, and indicates that the server is about to close the connection.

The BYE response is sent under one of four conditions:

1. as part of a normal logout sequence. The server will close the connection after sending the tagged OK response to the LOGOUT command.

2. as a panic shutdown announcement. The server closes the connection immediately.

3. as an announcement of an inactivity autologout. The server closes the connection immediately.

4. as one of three possible greetings at connection startup, indicating that the server is not willing to accept a connection from this client. The server closes the connection immediately.

The difference between a BYE that occurs as part of a normal LOGOUT sequence (the first case) and a BYE that occurs because of a failure (the other three cases) is that the connection closes immediately in the failure case. In all cases the client SHOULD continue to read response data from the server until the connection is closed; this will ensure that any pending untagged or completion responses are read and processed.

Implementations

impl<'a> Status<'a>

pub fn ok<T>( tag: Option<Tag<'a>>, code: Option<Code<'a>>, text: T ) -> Result<Self, T::Error>where T: TryInto<Text<'a>>,

pub fn no<T>( tag: Option<Tag<'a>>, code: Option<Code<'a>>, text: T ) -> Result<Self, T::Error>where T: TryInto<Text<'a>>,

pub fn bad<T>( tag: Option<Tag<'a>>, code: Option<Code<'a>>, text: T ) -> Result<Self, T::Error>where T: TryInto<Text<'a>>,

pub fn bye<T>(code: Option<Code<'a>>, text: T) -> Result<Self, T::Error>where T: TryInto<Text<'a>>,

pub fn tag(&self) -> Option<&Tag<'_>>

pub fn code(&self) -> Option<&Code<'_>>

pub fn text(&self) -> &Text<'_>

Trait Implementations

impl<'a> Arbitrary<'a> for Status<'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 Status<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Status<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for Status<'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 Status<'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 Status<'a>

type Static = Status<'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<Status<'a>> for Status<'a>

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

type Static = Status<'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 Status<'a>

impl<'a> StructuralEq for Status<'a>

impl<'a> StructuralPartialEq for Status<'a>