#msgpack #message-pack #serialization

deprecated rmp-serialize

Rust Serialize bindings for RMP

1 unstable release

Uses old Rust 2015

0.8.1 Sep 1, 2019
0.8.0 Jan 5, 2017
0.7.0 Aug 24, 2015

#16 in #rmp-serde

Download history 128/week @ 2023-11-02 133/week @ 2023-11-09 107/week @ 2023-11-16 117/week @ 2023-11-23 82/week @ 2023-11-30 107/week @ 2023-12-07 150/week @ 2023-12-14 142/week @ 2023-12-21 60/week @ 2023-12-28 108/week @ 2024-01-04 135/week @ 2024-01-11 177/week @ 2024-01-18 137/week @ 2024-01-25 127/week @ 2024-02-01 109/week @ 2024-02-08 162/week @ 2024-02-15

617 downloads per month
Used in 19 crates (9 directly)

MIT license

120KB
2K SLoC

RMP - MessagePack for legacy rustc-serialize

This crate is deprecated. Use rmp-serde instead.


lib.rs:

Examples

Let's try to encode a tuple of int and string.

extern crate rmp_serialize;
extern crate rustc_serialize;

use rustc_serialize::Encodable;
use rmp_serialize::Encoder;

fn main() {
    let val = (42u8, "the Answer");

    // The encoder borrows the bytearray buffer.
    let mut buf = [0u8; 13];

    val.encode(&mut Encoder::new(&mut &mut buf[..]));

    assert_eq!([0x92, 0x2a, 0xaa, 0x74, 0x68, 0x65, 0x20, 0x41, 0x6e, 0x73, 0x77, 0x65, 0x72], buf);
}

Now we have an encoded buffer, which we can decode the same way:

extern crate rmp_serialize;
extern crate rustc_serialize;

use rustc_serialize::Decodable;
use rmp_serialize::Decoder;

fn main() {
    let buf = [0x92, 0x2a, 0xaa, 0x74, 0x68, 0x65, 0x20, 0x41, 0x6e, 0x73, 0x77, 0x65, 0x72];

    let mut decoder = Decoder::new(&buf[..]);

    let res: (u8, String) = Decodable::decode(&mut decoder).unwrap();

    assert_eq!((42u8, "the Answer".to_string()), res);
}

RMP also allows to automatically serialize/deserialize custom structures using rustc_serialize reflection. To enable this feature, derive RustcEncodable and RustcDecodable attributes as shown in the following example:

extern crate rmp_serialize;
extern crate rustc_serialize;

use rustc_serialize::{Encodable, Decodable};
use rmp_serialize::{Encoder, Decoder};

#[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
struct Custom {
    id: u32,
    key: String,
}

fn main() {
    let val = Custom { id: 42u32, key: "the Answer".to_string() };

    let mut buf = [0u8; 13];

    val.encode(&mut Encoder::new(&mut &mut buf[..]));

    assert_eq!([0x92, 0x2a, 0xaa, 0x74, 0x68, 0x65, 0x20, 0x41, 0x6e, 0x73, 0x77, 0x65, 0x72], buf);

    // Now try to unpack the buffer into the initial struct.
    let mut decoder = Decoder::new(&buf[..]);
    let res: Custom = Decodable::decode(&mut decoder).ok().unwrap();

    assert_eq!(val, res);
}

Dependencies

~505KB