Crate packable 

Packable is a binary serialization and deserialization framework.

Design

Values of a type can be serialized and deserialized if the type implements the Packable trait. The serialization strategy used for each type is up to the user. However, Packable can also be derived, this provides a consistent serialization strategy.

For more information about the design of this crate please read the Packable, unpacker, packer, UnpackError and UnpackErrorExt documentation.

no_std compatibility

Packable is no_std compatible. This is achieved by introducing the Packer and Unpacker traits to abstract away any IO operation without relying on std::io. This has the additional benefit of allowing us to pack and unpack values from different kinds of buffers.

Types that implement Packable

The Packable trait is implemented for every sized integer type by encoding the value as an array of bytes in little-endian order.

Booleans are packed following Rust’s data layout, meaning that true is packed as a 1 byte and false as a 0 byte. However, boolean unpacking is less strict and unpacks any non-zero byte as true.

Types such as Box<[T]>, [T; N] and Option<T> implement Packable if T implements Packable.

This crate also provides bounded integers under the bounded module which have additional syntactical checks to guarantee that the deserialized values are in-bounds. It is also possible to serialize and deserialize sequences of values by using the types provided in the prefix module, which represent linear sequences of values with a length prefix.

Check the Packable impl section for further information.

Features

io

This feature provides the types IoPacker and IoUnpacker which allow packing and unpacking from values whose types implement Write and Read respectively.

primitive-types

This feature implements Packable for U256 encoding its values as arrays of bytes in little-endian order.

serde

This feature derives Serialize and Deserialize for the types provided in the bounded and prefix modules

std

This feature implements Error for all the error types provided by this crate.

usize

This feature implements Packable for usize, isize, Vec<T>, Box<[T]> and [String]. This is done serializing and deserializing pointer sized integers as 64-bit integers. This feature will not work for targets with a pointer width larger than 64.

Modules

bounded

Types and utilities related to bounded integers.

error

Errors related to packable operations.

map

Types and implementations for packing and unpacking map values.

option

Types and utilities related to packing and unpacking Option values.

packer

A module to pack any value that implements Packable.

prefix

Types and utilities used to pack and unpack dynamic sequences of values with restricted length prefixes.

set

Types and implementations for packing and unpacking set values.

unpacker

A module to unpack any value that implements Packable.

Traits

Packable

A type that can be packed and unpacked.

PackableExt

Extension trait for types that implement Packable.

Derive Macros

Packable