Struct BitWriter 

pub struct BitWriter { /* private fields */ }

A byte-buffer builder that packs fields LSB-first at the bit level.

Created with BitWriter::new, written to with write_* methods, and finalized with BitWriter::finish which flushes any partial byte and returns the completed buffer.

Sub-byte fields are accumulated in a single byte; once 8 bits are filled the byte is flushed. Multi-byte writes (e.g. write_u16) first align to a byte boundary, then append little-endian bytes directly.

Implementations

impl BitWriter

pub fn new() -> Self

Create a new, empty BitWriter.

pub fn write_bits(&mut self, value: u64, count: u8)

Write count bits from value, LSB first.

pub fn write_bool(&mut self, v: bool)

Write a single boolean as 1 bit.

pub fn flush_to_byte_boundary(&mut self)

Flush any partial byte to the buffer.

Special case per spec §4.1: if nothing has been written at all (bit_offset == 0 AND buf is empty), push a zero byte anyway. If bit_offset == 0 and buf is non-empty, this is a no-op.

pub fn write_u8(&mut self, v: u8)

Write a u8, aligning to a byte boundary first.

pub fn write_u16(&mut self, v: u16)

Write a u16 in little-endian byte order, aligning first.

pub fn write_u32(&mut self, v: u32)

Write a u32 in little-endian byte order, aligning first.

pub fn write_u64(&mut self, v: u64)

Write a u64 in little-endian byte order, aligning first.

pub fn write_i8(&mut self, v: i8)

Write an i8, aligning to a byte boundary first.

pub fn write_i16(&mut self, v: i16)

Write an i16 in little-endian byte order, aligning first.

pub fn write_i32(&mut self, v: i32)

Write an i32 in little-endian byte order, aligning first.

pub fn write_i64(&mut self, v: i64)

Write an i64 in little-endian byte order, aligning first.

pub fn write_f32(&mut self, v: f32)

Write an f32, canonicalizing NaN to 0x7FC00000.

pub fn write_f64(&mut self, v: f64)

Write an f64, canonicalizing NaN to 0x7FF8000000000000.

pub fn write_leb128(&mut self, v: u64)

Write a LEB128-encoded unsigned integer.

pub fn write_zigzag(&mut self, v: i64, type_bits: u8)

Write a ZigZag + LEB128 encoded signed integer.

pub fn write_string(&mut self, s: &str)

Write a UTF-8 string with a LEB128 length prefix.

pub fn write_bytes(&mut self, data: &[u8])

Write a byte slice with a LEB128 length prefix.

pub fn write_raw_bytes(&mut self, data: &[u8])

Write raw bytes with no length prefix.

pub fn enter_recursive(&mut self) -> Result<(), EncodeError>

Increment recursion depth; return error if limit exceeded.

pub fn leave_recursive(&mut self)

Decrement recursion depth.

pub fn finish(self) -> Vec<u8>

Flush any partial byte and return the finished buffer.

Trait Implementations

impl Default for BitWriter

fn default() -> Self

Returns the “default value” for a type.