https://github.com/codx-dev/msgpacker
MessagePack serializer implementation for Rust / msgpack.org[Rust]
https://github.com/codx-dev/msgpacker
messagepack msgpack rust
Last synced: 5 months ago
JSON representation
MessagePack serializer implementation for Rust / msgpack.org[Rust]
- Host: GitHub
- URL: https://github.com/codx-dev/msgpacker
- Owner: codx-dev
- License: apache-2.0
- Created: 2021-10-23T00:37:00.000Z (over 3 years ago)
- Default Branch: main
- Last Pushed: 2024-10-14T10:26:34.000Z (8 months ago)
- Last Synced: 2024-12-14T05:30:49.237Z (6 months ago)
- Topics: messagepack, msgpack, rust
- Language: Rust
- Homepage: https://msgpack.org/
- Size: 3.68 MB
- Stars: 14
- Watchers: 1
- Forks: 4
- Open Issues: 4
-
Metadata Files:
- Readme: README.md
- License: LICENSE-APACHE
Awesome Lists containing this project
README
# MessagePacker - a no-std msgpack implementation
[](https://crates.io/crates/msgpacker)
[](https://docs.rs/msgpacker/)
[]()
The protocol specification can be found [here](https://github.com/msgpack/msgpack/blob/master/spec.md).
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
```rust
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,
// This is also automatically implemented. The manual implementation is via `#[msgpacker(array)]`.
zones: Vec,
}
// 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](https://crates.io/crates/rmp-serde).
#### Pack 1.000 elements
#### Unpack 1.000 elements
