Struct Cut 

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

A cursor over a frozen body.

Every read either moves the cursor forward and answers, or answers Broken::Short and leaves the cursor wherever it was. There is no way to go backwards, because nothing that reads one of these needs to: a form is written in the order it is read.

Implementations

impl<'a> Cut<'a>

pub const fn new(bytes: &'a [u8]) -> Cut<'a>

A cursor at the start of bytes.

pub fn byte(&mut self) -> Result<u8, Broken>

The next byte.

pub fn uint(&mut self) -> Result<u64, Broken>

The next LEB128 number.

Ten groups at most, which is what a u64 takes, so a payload of nothing but continuation bits cannot spin here.

pub fn int(&mut self) -> Result<i64, Broken>

The next zigzagged number.

pub fn f64(&mut self) -> Result<f64, Broken>

The next double, from its eight raw bytes.

pub fn take(&mut self, n: usize) -> Result<&'a [u8], Broken>

The next n bytes.

pub fn bytes(&mut self) -> Result<&'a [u8], Broken>

The next length prefixed byte string.

pub const fn rest(&self) -> &'a [u8]

Everything from here to the end, which is what a form that ends in one blob wants.

A blob at the end of a form needs no length, because the frozen body is its own length. That is the whole reason the two forms that hand back a structure Redis already knows how to lay out cost one byte of overhead.