Struct bitcode::Buffer

pub struct Buffer(_);

A buffer for reusing allocations between any number of calls to Buffer::serialize and/or Buffer::deserialize.

Usage

use bitcode::Buffer;

// We preallocate buffers with capacity 1000. This will allow us to serialize and deserialize
// without any allocations as long as the encoded object takes less than 1000 bytes.
let bytes = 1000;
let mut ser_buf = Buffer::with_capacity(bytes);
let mut de_buf = Buffer::with_capacity(bytes);

// The object that we will serialize.
let target: [u8; 5] = [1, 2, 3, 4, 5];

// We serialize into `ser_buf`. This won't cause any allocations.
let encoded: &[u8] = ser_buf.serialize(&target).unwrap();
assert!(encoded.len() <= bytes, "oh no we allocated");

// We deserialize into `de_buf` because `encoded` is borrowing `ser_buf`.
let decoded: [u8; 5] = de_buf.deserialize(&encoded).unwrap();
assert_eq!(target, decoded);

// If we need ownership of `encoded`, we can convert it to a vec.
// This will allocate, but it's still more efficient than calling bitcode::serialize.
let _owned: Vec<u8> = encoded.to_vec();

Implementations

impl Buffer

pub fn new() -> Self

Constructs a new buffer without any capacity.

pub fn with_capacity(capacity: usize) -> Self

Constructs a new buffer with at least the specified capacity in bytes.

impl Buffer

pub fn serialize<T>(&mut self, t: &T) -> Result<&[u8], Error>where T: Serialize + ?Sized,

Serializes a T: Serialize into a &[u8]. Can reuse the buffer’s allocations.

Even if you call to_vec on the &[u8], it’s still more efficient than serialize.

Warning: The format is subject to change between versions.

pub fn deserialize<'a, T>(&mut self, bytes: &'a [u8]) -> Result<T, Error>where T: Deserialize<'a>,

Deserializes a &[u8] into an instance of T: Deserialize. Can reuse the buffer’s allocations.

Warning: The format is subject to change between versions.

Trait Implementations

impl Default for Buffer

fn default() -> Buffer

Returns the “default value” for a type.