Struct Str

pub struct Str(pub Vec<u8>);

String objects of MessagePack are essentially byte arrays type that may contain any bytes.

String type vs Binary type

MessagePack has a complicated history about its distinction between string type and binary type.

While an earlier version of MessagePack had only one type for encoding a binary data, namely the raw type, it was later divided into two distinct types for supporting use cases in dynamically-typed languages. ¹ The string type, one of the newly added types, is essentially what was originally called the raw type. Because of this origin, despite its name, string objects of MessagePack can contain not just valid UTF-8 sequences but also any byte sequences. And encoding non-UTF-8 byte sequences as a string object is a perfectly valid and expected usage by the spec authors.

So which to use in encoding my binary data?

When you decide to implement a custom serializer/deserializer for your own binary type, it is recommended to use string type instead of binary type for its encoding scheme for the following reasons.

• It just saves some memory. If your byte array is less than 32 byte length, using string type instead of byte array saves one byte per object.
• The disiction only matters when not using a data schema. Because this crate offers a statically-typed data schema, and we know how to decode data into a Rust object at compile time, distinction of these types in the input binary data is almost useless,

Although we strongly recommend you to use string types rather than binary types, this crate does not force you to do so. The functions and trait implementations provided by this crate are all taking a neutral stand.

---

1. https://github.com/msgpack/msgpack/issues/121 ↩

Tuple Fields

0: Vec<u8>

Implementations

impl Str

pub fn into_bytes(self) -> Vec<u8>

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

Trait Implementations

impl Arbitrary for Str

type Parameters = <Vec<u8> as Arbitrary>::Parameters

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<<Vec<u8> as Arbitrary>::Strategy, fn(Vec<u8>) -> Str>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_top: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for Str

fn clone(&self) -> Str

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Str

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

Formats the value using the given formatter.

impl From<Str> for Value

fn from(v: Str) -> Self

Converts to this type from the input type.

impl From<String> for Str

fn from(x: String) -> Self

Converts to this type from the input type.

impl PartialEq for Str

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

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

const 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 Eq for Str

impl StructuralPartialEq for Str