Struct BufferedLeb128Reader 

pub struct BufferedLeb128Reader<R, P = NonStrict> { /* private fields */ }

Buffered reader for LEB128 integers.

Values are decoded directly from the internal input buffer while the codec scans for the LEB128 terminating byte.

Buffered state

This reader may prefetch bytes from the wrapped reader. As a result, Self::inner can observe an underlying stream position ahead of the logical position exposed by this wrapper, and Self::into_inner discards any prefetched bytes that have not been consumed.

Target-width integers

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

Implementations

impl<R, P> BufferedLeb128Reader<R, P>

where P: DecodePolicy,

pub fn new(inner: R) -> Self

Creates a buffered LEB128 reader with the default buffer capacity.

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

Creates a buffered LEB128 reader with at least capacity bytes.

pub const fn is_strict(&self) -> bool

Returns whether this reader rejects non-canonical encodings.

pub const fn inner(&self) -> &R

Returns a shared reference to the underlying reader.

The underlying reader may already be positioned past unread bytes held in this wrapper’s internal buffer.

pub fn inner_mut(&mut self) -> &mut R

Returns an exclusive reference to the underlying reader.

Mutating the underlying reader directly can invalidate prefetched bytes already held in this wrapper’s internal buffer.

pub fn into_inner(self) -> R

Consumes this wrapper and returns the underlying reader.

Any bytes already prefetched into the internal buffer but not consumed by codec methods are discarded.

impl<R> BufferedLeb128Reader<R, NonStrict>

where R: Read,

pub fn read_u8(&mut self) -> Result<u8>

Reads an unsigned LEB128 u8.

pub fn read_u16(&mut self) -> Result<u16>

Reads an unsigned LEB128 u16.

pub fn read_u32(&mut self) -> Result<u32>

Reads an unsigned LEB128 u32.

pub fn read_u64(&mut self) -> Result<u64>

Reads an unsigned LEB128 u64.

pub fn read_u128(&mut self) -> Result<u128>

Reads an unsigned LEB128 u128.

pub fn read_usize(&mut self) -> Result<usize>

Reads an unsigned LEB128 usize.

pub fn read_i8(&mut self) -> Result<i8>

Reads a signed LEB128 i8.

pub fn read_i16(&mut self) -> Result<i16>

Reads a signed LEB128 i16.

pub fn read_i32(&mut self) -> Result<i32>

Reads a signed LEB128 i32.

pub fn read_i64(&mut self) -> Result<i64>

Reads a signed LEB128 i64.

pub fn read_i128(&mut self) -> Result<i128>

Reads a signed LEB128 i128.

pub fn read_isize(&mut self) -> Result<isize>

Reads a signed LEB128 isize.

pub fn read_utf8_string(&mut self, max_len: usize) -> Result<String>

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

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

impl<R> BufferedLeb128Reader<R, Strict>

where R: Read,

pub fn read_u8(&mut self) -> Result<u8>

Reads an unsigned LEB128 u8.

pub fn read_u16(&mut self) -> Result<u16>

Reads an unsigned LEB128 u16.

pub fn read_u32(&mut self) -> Result<u32>

Reads an unsigned LEB128 u32.

pub fn read_u64(&mut self) -> Result<u64>

Reads an unsigned LEB128 u64.

pub fn read_u128(&mut self) -> Result<u128>

Reads an unsigned LEB128 u128.

pub fn read_usize(&mut self) -> Result<usize>

Reads an unsigned LEB128 usize.

pub fn read_i8(&mut self) -> Result<i8>

Reads a signed LEB128 i8.

pub fn read_i16(&mut self) -> Result<i16>

Reads a signed LEB128 i16.

pub fn read_i32(&mut self) -> Result<i32>

Reads a signed LEB128 i32.

pub fn read_i64(&mut self) -> Result<i64>

Reads a signed LEB128 i64.

pub fn read_i128(&mut self) -> Result<i128>

Reads a signed LEB128 i128.

pub fn read_isize(&mut self) -> Result<isize>

Reads a signed LEB128 isize.

pub fn read_utf8_string(&mut self, max_len: usize) -> Result<String>

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

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

Trait Implementations

impl<R, P> Read for BufferedLeb128Reader<R, P>

where R: Read,

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

Reads bytes from the buffered reader.

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

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Reads the exact number of bytes required to fill cursor.

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

where Self: Sized,

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

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

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

Read and return a fixed array of bytes from this source.

impl<R, P> Seek for BufferedLeb128Reader<R, P>

where R: Read + Seek,

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

Seeks the wrapped reader and discards buffered bytes after success.

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.