#binary #no-std #serialization

no-std packable

A crate for packing and unpacking binary representations

21 unstable releases (10 breaking)

0.11.0 Feb 9, 2024
0.10.0 Nov 17, 2023
0.8.1 May 2, 2023
0.8.0 Mar 31, 2023
0.2.1 Feb 11, 2022

#132 in Encoding

Download history 784/week @ 2023-11-02 697/week @ 2023-11-09 1363/week @ 2023-11-16 1428/week @ 2023-11-23 1183/week @ 2023-11-30 943/week @ 2023-12-07 954/week @ 2023-12-14 462/week @ 2023-12-21 368/week @ 2023-12-28 1204/week @ 2024-01-04 1479/week @ 2024-01-11 2584/week @ 2024-01-18 1114/week @ 2024-01-25 1554/week @ 2024-02-01 1919/week @ 2024-02-08 1581/week @ 2024-02-15

6,647 downloads per month
Used in 16 crates (8 directly)

Apache-2.0

105KB
2K SLoC

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.

License: Apache-2.0

Dependencies

~2.8–4MB
~77K SLoC