1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
//! # The Rust MessagePack Library //! //! RMP is a pure Rust [MessagePack](http://msgpack.org) implementation. //! //! MessagePack is an efficient binary serialization format. //! //! **Warning** this library is still in rapid development and everything may change until 1.0 comes. //! //! ## Usage //! //! To use `rmp`, first add this to your `Cargo.toml`: //! //! ```toml //! [dependencies.rmp] //! rmp = "^0.7" //! ``` //! //! Then, add this to your crate root: //! //! ```rust //! extern crate rmp as msgpack; // Or just `rmp`. //! ``` //! //! ## Features //! //! - **Convenient API** //! //! RMP is designed to be lightweight and straightforward. There are low-level API, which gives you //! full control on data encoding/decoding process and makes no heap allocations. On the other hand //! there are high-level API, which provides you convenient interface using Rust standard library and //! compiler reflection, allowing to encode/decode structures using `derive` attribute. //! //! - **Zero-copy value decoding** //! //! RMP allows to decode bytes from a buffer in a zero-copy manner easily and blazingly fast, while Rust //! static checks guarantees that the data will be valid until buffer lives. //! //! - **Clear error handling** //! //! RMP's error system guarantees that you never receive an error enum with unreachable variant. //! //! - **Robust and tested** //! //! This project is developed using TDD and CI, so any found bugs will be fixed without breaking //! existing functionality. //! //! ## Detailed //! //! This crate represents the very basic functionality needed to work with MessagePack format. //! Ideologically it is developed as a basis for building high-level abstractions. //! //! Currently there are three large modules: encode, decode and value. More detail you can find //! in the corresponding sections. //! //! Formally every MessagePack message consists of some marker encapsulating a date type and the //! data itself. Sometimes there are no separate data chunk, for example for booleans. In these //! cases a marker contains the value. For example, the `true` value is encoded as `0xc3`. //! //! Also note, that a single value can be encoded in multiple ways. For example a value of `42` can //! be represented as: `[0x2a], [0xcc, 0x2a], [0xcd, 0x00, 0x2a]` and so on. //! //! In these cases RMP guarantees that for encoding the most compact representation will be chosen. //! On the other hand for deserialization it is not matter in which representation the value is //! encoded - RMP deals with all of them. //! //! ## API //! //! Almost all API are represented as pure functions, which accepts a generic `Write` and the value. extern crate byteorder; pub mod encode; pub mod decode; mod init; pub mod value; pub const MSGPACK_VERSION : u32 = 5; pub use init::Marker; pub use value::{Value, ValueRef};