Struct rocket::serde::msgpack::MsgPack

pub struct MsgPack<T, const COMPACT: bool = false>(pub T);

Available on crate feature msgpack only.

The MessagePack guard: easily consume and return MessagePack.

Sending MessagePack

To respond with serialized MessagePack data, return either MsgPack<T> or Compact<T> from your handler. T must implement serde::Serialize.

use rocket::serde::msgpack::MsgPack;

#[get("/users/<id>")]
fn user(id: usize) -> MsgPack<User> {
    let user_from_id = User::from(id);
    /* ... */
    MsgPack(user_from_id)
}

The differences between MsgPack<T> and Compact<T> are documented on Compact<T>. In most cases, MsgPack<T> is preferable, although compact was the default prior to Rocket version 0.6.

Receiving MessagePack

MsgPack is both a data guard and a form guard.

Data Guard

To deserialize request body data as MessagePack, add a data route argument with a target type of MsgPack<T>, where T is some type you’d like to parse from JSON. T must implement serde::Deserialize.

use rocket::serde::msgpack::MsgPack;

#[post("/users", format = "msgpack", data = "<user>")]
fn new_user(user: MsgPack<User>) {
    /* ... */
}

You don’t need to use format = "msgpack", but it may be what you want. Using format = msgpack means that any request that doesn’t specify “application/msgpack” as its first Content-Type: header parameter will not be routed to this handler.

Form Guard

MsgPack<T>, as a form guard, accepts value and data fields and parses the data as a T. Simple use MsgPack<T>:

use rocket::form::{Form, FromForm};
use rocket::serde::msgpack::MsgPack;

#[derive(FromForm)]
struct User<'r> {
    name: &'r str,
    metadata: MsgPack<Metadata>
}

#[post("/users", data = "<form>")]
fn new_user(form: Form<User<'_>>) {
    /* ... */
}

Incoming Data Limits

The default size limit for incoming MessagePack data is 1MiB. Setting a limit protects your application from denial of service (DOS) attacks and from resource exhaustion through high memory consumption. The limit can be increased by setting the limits.msgpack configuration parameter. For instance, to increase the MessagePack limit to 5MiB for all environments, you may add the following to your Rocket.toml:

[global.limits]
msgpack = 5242880

Tuple Fields

0: T

Implementations

impl<T, const COMPACT: bool> MsgPack<T, COMPACT>

pub fn into_inner(self) -> T

Consumes the MsgPack wrapper and returns the wrapped item.

Example

let string = "Hello".to_string();
let my_msgpack: MsgPack<_> = MsgPack(string);
assert_eq!(my_msgpack.into_inner(), "Hello".to_string());

Trait Implementations

impl<T: Clone, const COMPACT: bool> Clone for MsgPack<T, COMPACT>

fn clone(&self) -> MsgPack<T, COMPACT>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const COMPACT: bool> Debug for MsgPack<T, COMPACT>

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

Formats the value using the given formatter.

impl<T, const COMPACT: bool> Deref for MsgPack<T, COMPACT>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, const COMPACT: bool> DerefMut for MsgPack<T, COMPACT>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T, const COMPACT: bool> From<T> for MsgPack<T, COMPACT>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<'r, T: Deserialize<'r>> FromData<'r> for MsgPack<T>

type Error = Error

The associated error to be returned when the guard fails.

fn from_data<'life0, 'async_trait>( req: &'r Request<'life0>, data: Data<'r>, ) -> Pin<Box<dyn Future<Output = Outcome<'r, Self>> + Send + 'async_trait>>

where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait,

Asynchronously validates, parses, and converts an instance of Self from the incoming request body data.

impl<'v, T: Deserialize<'v> + Send> FromFormField<'v> for MsgPack<T>

fn from_data<'life0, 'async_trait>( f: DataField<'v, 'life0>, ) -> Pin<Box<dyn Future<Output = Result<Self, Errors<'v>>> + Send + 'async_trait>>

where Self: 'async_trait, 'v: 'async_trait, 'life0: 'async_trait,

Parse a value of T from a form data field.

fn from_value(field: ValueField<'v>) -> Result<'v, Self>

Parse a value of T from a form value field.

fn default() -> Option<Self>

Returns a default value, if any exists, to be used during lenient parsing when the form field is missing.

impl<T: Hash, const COMPACT: bool> Hash for MsgPack<T, COMPACT>

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

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<L, T: Len<L>> Len<L> for MsgPack<T>

fn len(&self) -> L

The length of the value.

fn len_into_u64(len: L) -> u64

Convert len into u64.

fn zero_len() -> L

The zero value for L.

impl<T: Ord, const COMPACT: bool> Ord for MsgPack<T, COMPACT>

fn cmp(&self, other: &MsgPack<T, COMPACT>) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl<T: PartialEq, const COMPACT: bool> PartialEq for MsgPack<T, COMPACT>

fn eq(&self, other: &MsgPack<T, COMPACT>) -> 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<T: PartialOrd, const COMPACT: bool> PartialOrd for MsgPack<T, COMPACT>

fn partial_cmp(&self, other: &MsgPack<T, COMPACT>) -> 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<'r, T: Serialize, const COMPACT: bool> Responder<'r, 'static> for MsgPack<T, COMPACT>

Serializes the wrapped value into MessagePack. Returns a response with Content-Type MsgPack and a fixed-size body with the serialization. If serialization fails, an Err of Status::InternalServerError is returned.

fn respond_to(self, req: &'r Request<'_>) -> Result<'static>

Returns Ok if a Response could be generated successfully. Otherwise, returns an Err with a failing Status.

impl<T: Eq, const COMPACT: bool> Eq for MsgPack<T, COMPACT>

impl<T, const COMPACT: bool> StructuralPartialEq for MsgPack<T, COMPACT>