Struct imap_codec::core::Literal

pub struct Literal<'a> { /* private fields */ }

A sequence of zero or more (non-null) bytes prefixed with a length.

“A literal is a sequence of zero or more octets (including CR and LF), prefix-quoted with an octet count in the form of an open brace (”{“), the number of octets, close brace (”}“), and CRLF. In the case of literals transmitted from server to client, the CRLF is immediately followed by the octet data. In the case of literals transmitted from client to server, the client MUST wait to receive a command continuation request (…) before sending the octet data (and the remainder of the command).

Note: Even if the octet count is 0, a client transmitting a literal MUST wait to receive a command continuation request.“ (RFC 3501)

ABNF definition

literal = "{" number "}" CRLF *CHAR8
          ; Number represents the number of CHAR8s
number  = 1*DIGIT
          ; Unsigned 32-bit integer
          ; (0 <= n < 4,294,967,296)
DIGIT   = %x30-39
          ; 0-9
CRLF    = CR LF
          ; Internet standard newline
CHAR8   = %x01-ff
          ; any OCTET except NUL, %x00

Implementations

impl<'a> Literal<'a>

pub fn validate(value: impl AsRef<[u8]>) -> Result<(), LiteralError>

pub fn data(&self) -> &[u8]

pub fn mode(&self) -> LiteralMode

pub fn set_mode(&mut self, mode: LiteralMode)

pub fn into_sync(self) -> Literal<'a>

pub fn into_non_sync(self) -> Literal<'a>

pub fn into_inner(self) -> Cow<'a, [u8]>

pub fn unvalidated<D>(data: D) -> Literal<'a>where D: Into<Cow<'a, [u8]>>,

Constructs a literal without validation.

Warning: IMAP conformance

The caller must ensure that data is valid according to Self::validate. Failing to do so may create invalid/unparsable IMAP messages, or even produce unintended protocol flows. Do not call this constructor with untrusted data.

pub fn unvalidated_non_sync<D>(data: D) -> Literal<'a>where D: Into<Cow<'a, [u8]>>,

Trait Implementations

impl<'a> Arbitrary<'a> for Literal<'a>

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Literal<'a>, Error>

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> AsRef<[u8]> for Literal<'a>

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for Literal<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Literal<'a>

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

Formats the value using the given formatter.

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

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

Deserialize this value from the given Serde deserializer.

impl<'a> From<Literal<'a>> for AString<'a>

fn from(value: Literal<'a>) -> AString<'a>

Converts to this type from the input type.

impl<'a> From<Literal<'a>> for IString<'a>

fn from(value: Literal<'a>) -> IString<'a>

Converts to this type from the input type.

impl<'a> From<Literal<'a>> for NString<'a>

fn from(value: Literal<'a>) -> NString<'a>

Converts to this type from the input type.

impl<'a> Hash for Literal<'a>

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

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 Literal<'a>

type Static = Literal<'static>

The target type is bounded by the 'static lifetime.

fn into_static(self) -> <Literal<'a> as IntoBoundedStatic>::Static

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

impl<'a> PartialEq<Literal<'a>> for Literal<'a>

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

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

Serialize this value into the given Serde serializer.

impl<'a> ToBoundedStatic for Literal<'a>

type Static = Literal<'static>

The target type is bounded by the 'static lifetime.

fn to_static(&self) -> <Literal<'a> as ToBoundedStatic>::Static

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

impl<'a> TryFrom<&'a [u8]> for Literal<'a>

type Error = LiteralError

The type returned in the event of a conversion error.

fn try_from( value: &'a [u8] ) -> Result<Literal<'a>, <Literal<'a> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Literal<'a>

type Error = LiteralError

The type returned in the event of a conversion error.

fn try_from( value: &'a str ) -> Result<Literal<'a>, <Literal<'a> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl<'a> TryFrom<String> for Literal<'a>

type Error = LiteralError

The type returned in the event of a conversion error.

fn try_from( value: String ) -> Result<Literal<'a>, <Literal<'a> as TryFrom<String>>::Error>

Performs the conversion.

impl<'a> TryFrom<Vec<u8, Global>> for Literal<'a>

type Error = LiteralError

The type returned in the event of a conversion error.

fn try_from( value: Vec<u8, Global> ) -> Result<Literal<'a>, <Literal<'a> as TryFrom<Vec<u8, Global>>>::Error>

Performs the conversion.

impl<'a> Eq for Literal<'a>

impl<'a> StructuralEq for Literal<'a>

impl<'a> StructuralPartialEq for Literal<'a>