Struct BufferedLeb128Writer 

pub struct BufferedLeb128Writer<W> { /* private fields */ }

Buffered writer for canonical LEB128 integers.

Values are encoded directly into the internal output buffer and flushed to the wrapped writer in larger chunks.

Flush contract

Pending buffered bytes are not flushed from Drop. Call Write::flush or Self::into_inner to guarantee that all bytes reach the wrapped writer. Self::get_ref and Self::get_mut can observe the wrapped writer before pending bytes have been flushed.

Target-width integers

usize and isize methods use the current Rust target’s pointer width. Prefer fixed-width integer methods such as write_u64 or write_i64 for persistent files and cross-platform protocols.

Implementations

impl<W> BufferedLeb128Writer<W>

pub fn new(inner: W) -> Self

Creates a buffered LEB128 writer with the default buffer capacity.

pub fn with_capacity(inner: W, capacity: usize) -> Self

Creates a buffered LEB128 writer with at least capacity bytes.

pub const fn get_ref(&self) -> &W

Returns a shared reference to the underlying writer.

Pending bytes may still be held in this wrapper’s internal buffer.

pub fn get_mut(&mut self) -> &mut W

Returns an exclusive reference to the underlying writer.

Pending bytes may still be held in this wrapper’s internal buffer. Flush first if the underlying writer must observe all previous writes.

impl<W> BufferedLeb128Writer<W>

where W: Write,

pub fn into_inner(self) -> Result<W>

Flushes pending bytes and returns the underlying writer.

pub fn write_utf8_string(&mut self, value: &str) -> Result<()>

Writes a UTF-8 string prefixed by an unsigned LEB128 byte length.

The length prefix is encoded as usize, so this format is target-width dependent. Prefer a fixed-width length prefix for persistent files and cross-platform protocols.

impl<W> BufferedLeb128Writer<W>

where W: Write,

pub fn write_u8(&mut self, value: u8) -> Result<()>

Writes an unsigned LEB128 u8.

pub fn write_u16(&mut self, value: u16) -> Result<()>

Writes an unsigned LEB128 u16.

pub fn write_u32(&mut self, value: u32) -> Result<()>

Writes an unsigned LEB128 u32.

pub fn write_u64(&mut self, value: u64) -> Result<()>

Writes an unsigned LEB128 u64.

pub fn write_u128(&mut self, value: u128) -> Result<()>

Writes an unsigned LEB128 u128.

pub fn write_usize(&mut self, value: usize) -> Result<()>

Writes an unsigned LEB128 usize.

pub fn write_i8(&mut self, value: i8) -> Result<()>

Writes a signed LEB128 i8.

pub fn write_i16(&mut self, value: i16) -> Result<()>

Writes a signed LEB128 i16.

pub fn write_i32(&mut self, value: i32) -> Result<()>

Writes a signed LEB128 i32.

pub fn write_i64(&mut self, value: i64) -> Result<()>

Writes a signed LEB128 i64.

pub fn write_i128(&mut self, value: i128) -> Result<()>

Writes a signed LEB128 i128.

pub fn write_isize(&mut self, value: isize) -> Result<()>

Writes a signed LEB128 isize.

Trait Implementations

impl<W> Seek for BufferedLeb128Writer<W>

where W: Write + Seek,

fn seek(&mut self, position: SeekFrom) -> Result<u64>

Flushes pending bytes before seeking the wrapped writer.

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream.

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes).

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream.

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position.

impl<W> Write for BufferedLeb128Writer<W>

where W: Write,

fn write(&mut self, buffer: &[u8]) -> Result<usize>

Writes bytes through the internal buffer.

fn write_all(&mut self, buffer: &[u8]) -> Result<()>

Writes all bytes through the internal buffer.

fn flush(&mut self) -> Result<()>

Flushes the internal buffer and then the wrapped writer.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.