Crate xxai_msgpacker

MessagePacker - a no-std msgpack implementation

The protocol specification can be found here.

This crate targets simplicity and performance. No dependencies are used, just the standard Rust library.

It will implement Packable and Unpackable for Rust atomic types. The traits can also be implemented manually.

Features

• alloc: Implements the functionality for Vec, String, and unlocks custom extensions.
• derive: Enables MsgPacker derive convenience macro.
• strict: Will panic if there is a protocol violation of the size of a buffer; the maximum allowed size is u32::MAX.
• std: Will implement the Packable and Unpackable for std collections.

Example

use msgpacker::prelude::*;
use std::collections::HashMap;

// boilerplate derives - those aren't required
#[derive(Debug, PartialEq, Eq)]
// this convenience derive macro will implement `Packable` and `Unpackable`
#[derive(MsgPacker)]
pub struct City {
    name: String,

    // The traits are implemented for stdlib collections. If you have a custom map, you can use the
    // directive `#[msgpacker(map)]` so the traits will be automatically implemented through the
    // iterators of the map.
    inhabitants_per_street: HashMap<String, u64>,

    // This is also automatically implemented. The manual implementation is via `#[msgpacker(array)]`.
    zones: Vec<String>,
}

// create an instance of a city.
let city = City {
    name: "Kuala Lumpur".to_string(),
    inhabitants_per_street: HashMap::from([
        ("Street 1".to_string(), 10),
        ("Street 2".to_string(), 20),
    ]),
    zones: vec!["Zone 1".to_string(), "Zone 2".to_string()],
};

// serialize the city into bytes
let mut buf = Vec::new();
let n = city.pack(&mut buf);
println!("serialized {} bytes", n);

// deserialize the city and assert correctness
let (n, deserialized) = City::unpack(&buf).unwrap();
println!("deserialized {} bytes", n);
assert_eq!(city, deserialized);

Benchmarks

Results obtained with Intel(R) Core(TM) i9-9900X CPU @ 3.50GHz.

The simplicity of the implementation unlocks a performance more than ~10x better than rmp-serde.

Pack 1.000 elements

Unpack 1.000 elements

Modules

• prelude
  Required types for the library.

Enums

• Error
  Deserialization errors for the protocol implementation.
• Extension
  Custom extension definition as reference to a bytes source.

Traits

• Packable
  A packable type.
• Unpackable
  An unpackable type.

Functions

• pack_array
  Packs an array into the extendable buffer, returning the amount of written bytes.
• pack_map
  Packs a map into the extendable buffer, returning the amount of written bytes.
• unpack_array
  Unpacks an array from the buffer, returning a collectable type and the amount of read bytes.
• unpack_array_iter
  Unpacks an array from the iterator, returning a collectable type and the amount of read bytes.
• unpack_map
  Unpacks a map from the buffer, returning a collectable type and the amount of read bytes.
• unpack_map_iter
  Unpacks a map from the iterator, returning a collectable type and the amount of read bytes.

Derive Macros

• MsgPacker