Crate hubpack

A predictable serialization format for serde.

hubpack is an algorithm for converting Rust values to bytes and back. It was originally designed for encoding messages sent between embedded programs. It is designed for use with serde.

Some of the nice things about hubpack include:

• Its encoding format is relatively compact.

• Its encoding format is predictable. In particular, there are no variable-length integer encodings.

• Because the size is predictable, hubpack provides a SerializedSize trait. Any type that implements SerializedSize can report the maximum number of bytes necessary to encode it using hubpack. This means you can allocate a fixed-size buffer without worry. (You can #[derive(SerializedSize)] for your own types.)

• The encode/decode implementations generate fairly small, efficient code.

• The implementation uses very little unsafe code, only in specific cases with a measurable performance improvement and no reasonable alternative.

You might not want to use hubpack because of the following limitations:

• hubpack is designed for fixed-size small data structures, and cannot encode things like Vec, str, and maps.

• hubpack does not support enum types with more than 256 variants.

• hubpack aims for predictability over compactness, so certain types of data – like lots of integers whose values are small relative to their types – can be more compactly encoded using formats like bincode.

Re-exports

• pub use de::deserialize;
• pub use error::Error;
• pub use error::Result;
• pub use ser::serialize;
• pub use size::SerializedSize;

Modules

• de
  Deserializing hubpack-encoded values back into Rust.
• error
  Error type.
• ser
  Serialization of Rust values into hubpack format.
• size
  Reasoning about the maximum encoded size of types.

Derive Macros

• SerializedSize
  Derive macro for the SerializedSize trait.