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