Enum Format 

pub enum Format {
    PositiveFixInt(u8),
    FixMap(u8),
    FixArray(u8),
    FixStr(u8),
    Nil,
    NeverUsed,
    False,
    True,
    Bin8,
    Bin16,
    Bin32,
    Ext8,
    Ext16,
    Ext32,
    Float32,
    Float64,
    Uint8,
    Uint16,
    Uint32,
    Uint64,
    Int8,
    Int16,
    Int32,
    Int64,
    FixExt1,
    FixExt2,
    FixExt4,
    FixExt8,
    FixExt16,
    Str8,
    Str16,
    Str32,
    Array16,
    Array32,
    Map16,
    Map32,
    NegativeFixInt(i8),
}

MessagePack format marker.

Variants

PositiveFixInt(u8)

Positive fixint (0xxxxxxx): stores a positive 7‑bit integer in the marker.

FixMap(u8)

Fixmap (1000xxxx): small map with length encoded in the marker.

FixArray(u8)

Fixarray (1001xxxx): small array with length encoded in the marker.

FixStr(u8)

Fixstr (101xxxxx): small string with byte length in the marker.

Nil

Nil (0xc0).

NeverUsed

Reserved (0xc1): never used.

False

False (0xc2).

True

True (0xc3).

Bin8

Binary with 8‑bit length (0xc4).

Bin16

Binary with 16‑bit length (0xc5).

Bin32

Binary with 32‑bit length (0xc6).

Ext8

Extension with 8‑bit length (0xc7).

Ext16

Extension with 16‑bit length (0xc8).

Ext32

Extension with 32‑bit length (0xc9).

Float32

Float32 (0xca).

Float64

Float64 (0xcb).

Uint8

Unsigned 8‑bit integer (0xcc).

Uint16

Unsigned 16‑bit integer (0xcd).

Uint32

Unsigned 32‑bit integer (0xce).

Uint64

Unsigned 64‑bit integer (0xcf).

Int8

Signed 8‑bit integer (0xd0).

Int16

Signed 16‑bit integer (0xd1).

Int32

Signed 32‑bit integer (0xd2).

Int64

Signed 64‑bit integer (0xd3).

FixExt1

Fixext 1 (0xd4).

FixExt2

Fixext 2 (0xd5).

FixExt4

Fixext 4 (0xd6).

FixExt8

Fixext 8 (0xd7).

FixExt16

Fixext 16 (0xd8).

Str8

Str8: UTF‑8 string with 8‑bit length (0xd9).

Str16

Str16: UTF‑8 string with 16‑bit length (0xda).

Str32

Str32: UTF‑8 string with 32‑bit length (0xdb).

Array16

Array16: array with 16‑bit length (0xdc).

Array32

Array32: array with 32‑bit length (0xdd).

Map16

Map16: map with 16‑bit length (0xde).

Map32

Map32: map with 32‑bit length (0xdf).

NegativeFixInt(i8)

Negative fixint (111xxxxx): stores a negative 5‑bit integer in the marker.

Implementations

impl Format

pub const fn as_byte(&self) -> u8

Return the marker byte for this format.

pub const fn from_byte(byte: u8) -> Self

Parse a marker byte into a Format value.

pub const fn as_slice(&self) -> [u8; 1]

Return the marker byte wrapped in a single‑byte array.

Trait Implementations

impl Clone for Format

fn clone(&self) -> Format

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Format

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

Formats the value using the given formatter.

impl<'a> Decode<'a> for Format

type Value = Format

The materialised value type.

fn decode(buf: &'a [u8]) -> Result<(Self::Value, &'a [u8]), Error>

Decode a value from the front of buf, returning the value and the remaining slice.

fn decode_with_format( format: Format, buf: &'a [u8], ) -> Result<(Self::Value, &'a [u8]), Error>

Decode a value assuming the leading MessagePack format has already been read by the caller. Implementations must validate that format is appropriate for the type and return an error otherwise.

impl<W> Encode<W> for Format

where W: IoWrite,

fn encode(&self, writer: &mut W) -> Result<usize, Error<<W as IoWrite>::Error>>

Encode this value to MessagePack and write bytes to writer.

impl IntoIterator for Format

type Item = u8

The type of the elements being iterated over.

type IntoIter = IntoIter<u8, 1>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Ord for Format

fn cmp(&self, other: &Format) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Format

fn eq(&self, other: &Format) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Format

fn partial_cmp(&self, other: &Format) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Format

impl StructuralPartialEq for Format