Struct StackPacker 

pub struct StackPacker<'a, P, T>
where
    P: Packable + 'a,
    T: Packable + 'a,
{ /* private fields */ }

StackPacker is the type returned by StackPack. It’s a pointer to something packable (usually another StackPacker) and some type that we can directly pack. Both are packable, but it’s usually the case that the former is another StackPacker while the latter is the type being serialized in a call to pack.

Implementations

impl<'a, P, T> StackPacker<'a, P, T>

where P: Packable + 'a, T: Packable + 'a,

pub fn pack<'b, U: Packable + 'b>(&'b self, u: U) -> StackPacker<'b, Self, U>

pack returns a new StackPacker that will pack self at its prefix. This does not actually do the packing, but defers it until calls to e.g. into_slice. Consequently, the object u must not change between this call and subsequent calls. Rust’s type system generally enforces this by default, except where interior mutability is specifically added.

pub fn into_slice<'b>(&self, buf: &'b mut [u8]) -> &'b mut [u8]

into_slice packs the entire chain of pack() calls into the provided mutable buffer. The return value is a slice containing exactly those bytes written and no more.

pub fn to_vec(&self) -> Vec<u8>

to_vec allocates a new vector and packs the entire chain of pack() calls into it. The return value is a Vec<u8> sized to exactly the packed bytes.

pub fn append_to_vec(&self, v: &mut Vec<u8>)

append_to_vec is a helper to extend a vector by the requisite size and then pack into the newly created space.

pub fn length_prefixed(&'a self) -> LengthPrefixer<'a, StackPacker<'a, P, T>>

Create a Packable object that will pack like "<varint-length><bytes>" where the length indicates how many bytes there are. Nothing gets copied. Usually this gets passed to another stack_pack, which will do the work.

Trait Implementations

impl<'a, P, T> Packable for StackPacker<'a, P, T>

where P: Packable + 'a, T: Packable + 'a,

fn pack_sz(&self) -> usize

pack_sz returns the number of bytes required to serialize the Packable object.

fn pack(&self, out: &mut [u8])

pack fills in the buffer out with the packed binary representation of the Packable object. The implementor is responsible to ensure that out is exactly pack_sz() bytes and implementations are encouraged to assert this.

fn stream<W: Write>(&self, writer: &mut W) -> Result<usize, Error>

where Self: Sized, for<'a> &'a Self: Packable,

stream writes the object to the provided writer using the same representation that would be used in a call to pack. The implementor is responsible for making sure that the number of bytes written is exactly equal to the number of required bytes.