Crate bincode_purplecoin

Expand description

Bincode is a crate for encoding and decoding using a tiny binary serialization strategy. Using it, you can easily go from having an object in memory, quickly serialize it to bytes, and then deserialize it back just as fast!

If you’re coming from bincode 1, check out our migration guide

§Serde

Starting from bincode 2, serde is now an optional dependency. If you want to use serde, please enable the serde feature. See Features for more information.

§Features

Name	Default?	Supported types for Encode/Decode	Enabled methods	Other
std	Yes	`HashMap` and `HashSet`	`decode_from_std_read` and `encode_into_std_write`
alloc	Yes	All common containers in alloc, like `Vec`, `String`, `Box`	`encode_to_vec`
atomic	Yes	All `Atomic*` integer types, e.g. `AtomicUsize`, and `AtomicBool`
derive	Yes			Enables the `BorrowDecode`, `Decode` and `Encode` derive macros
serde	No	`Compat` and `BorrowCompat`, which will work for all types that implement serde’s traits	serde-specific encode/decode functions in the serde module	Note: There are several known issues when using serde and bincode

§Which functions to use

Bincode has a couple of pairs of functions that are used in different situations.

Situation	Encode	Decode
You’re working with `fs::File` or `net::TcpStream`	`encode_into_std_write`	`decode_from_std_read`
you’re working with in-memory buffers	`encode_to_vec`	`decode_from_slice`
You want to use a custom Reader and writer	`encode_into_writer`	`decode_from_reader`
You’re working with pre-allocated buffers or on embedded targets	`encode_into_slice`	`decode_from_slice`

Note: If you’re using serde, use bincode::serde::... instead of bincode::...

§Example

let mut slice = [0u8; 100];

// You can encode any type that implements `Encode`.
// You can automatically implement this trait on custom types with the `derive` feature.
let input = (
    0u8,
    10u32,
    10000i128,
    'a',
    [0u8, 1u8, 2u8, 3u8]
);

let length = bincode::encode_into_slice(
    input,
    &mut slice,
    bincode::config::standard()
).unwrap();

let slice = &slice[..length];
println!("Bytes written: {:?}", slice);

// Decoding works the same as encoding.
// The trait used is `Decode`, and can also be automatically implemented with the `derive` feature.
let decoded: (u8, u32, i128, char, [u8; 4]) = bincode::decode_from_slice(slice, bincode::config::standard()).unwrap().0;

assert_eq!(decoded, input);

Re-exports§

pub use de::BorrowDecode;
pub use de::Decode;
pub use enc::Encode;

Modules§

config: The config module is used to change the behavior of bincode’s encoding and decoding logic.
de: Decoder-based structs and traits.
enc: Encoder-based structs and traits.
error: Errors that can be encounting by Encoding and Decoding.
migration_guide: Migrating from bincode 1 to 2
serdeserde: Support for serde integration. Enable this with the serde feature.
spec: Serialization specification

Functions§

decode_from_reader: Attempt to decode a given type D from the given Reader.
decode_from_slice: Attempt to decode a given type D from the given slice.
decode_from_std_readstd: Decode type D from the given reader with the given Config. The reader can be any type that implements std::io::Read, e.g. std::fs::File.
encode_into_slice: Encode the given value into the given slice. Returns the amount of bytes that have been written.
encode_into_std_writestd: Encode the given value into any type that implements std::io::Write, e.g. std::fs::File, with the given Config. See the config module for more information.
encode_into_writer: Encode the given value into a custom Writer.
encode_to_vecalloc: Encode the given value into a Vec<u8> with the given Config. See the config module for more information.

Derive Macros§

BorrowDecodederive
Decodederive
Encodederive