Enum Frame 

#[non_exhaustive]
pub enum Frame<'a> {
    Simple(&'a [u8]),
    Error(&'a [u8]),
    BlobError(&'a [u8]),
    Int(i64),
    Bulk(&'a [u8]),
    Null,
    Double(f64),
    Bool(bool),
    BigNumber(&'a [u8]),
    Verbatim {
        format: &'a [u8],
        text: &'a [u8],
    },
    Array(Vec<Frame<'a>>),
    Map(Vec<(Frame<'a>, Frame<'a>)>),
    Set(Vec<Frame<'a>>),
    Push(Vec<Frame<'a>>),
    Attribute(Vec<(Frame<'a>, Frame<'a>)>),
}

One reply, borrowed from the buffer it arrived in.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Simple(&'a [u8])

+, a one line string.

Error(&'a [u8])

-, a one line error, prefix included.

BlobError(&'a [u8])

!, RESP3’s error that may span lines.

Int(i64)

:, an integer.

Bulk(&'a [u8])

$, a length prefixed string.

Null

A missing value: RESP2’s $-1 or *-1, or RESP3’s _.

The two RESP2 spellings decode to the same thing on purpose. A caller that needs to tell them apart is testing the protocol rather than the reply, and crate::Out is where that is tested.

Double(f64)

,, a double.

Bool(bool)

#, a boolean.

BigNumber(&'a [u8])

(, an integer too large for i64, as its digits.

Verbatim

=, a string with a three byte format tag.

Fields

format: &'a [u8]

The tag, such as txt or mkd.

text: &'a [u8]

Everything after the colon.

Array(Vec<Frame<'a>>)

*, an ordered list.

Map(Vec<(Frame<'a>, Frame<'a>)>)

%, pairs in the order they were sent.

Set(Vec<Frame<'a>>)

~, an unordered list.

Push(Vec<Frame<'a>>)

>, an out of band message: pub/sub delivery or a cache invalidation.

Attribute(Vec<(Frame<'a>, Frame<'a>)>)

|, metadata that belongs to the frame after it.

Returned on its own rather than attached, because attaching it would mean every caller matching on a reply has to look through a wrapper. A caller that cares reads the next frame; a caller that does not can drop it, which is what RESP3 says clients may do.

Implementations

impl Frame<'_>

pub fn is_error(&self) -> bool

Whether this is an error of either kind.

Trait Implementations

impl<'a> Clone for Frame<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Frame<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Frame<'a>

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> StructuralPartialEq for Frame<'a>