Struct BufferedZigZagReader 

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

Buffered reader for ZigZag + unsigned LEB128 integers.

Values are decoded directly from the internal input buffer while the codec scans for the underlying 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

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

Implementations

impl<R, P> BufferedZigZagReader<R, P>

where P: DecodePolicy,

pub fn new(inner: R) -> Self

Creates a buffered ZigZag reader with the default buffer capacity.

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

Creates a buffered ZigZag reader with at least capacity bytes.

pub const fn is_strict(&self) -> bool

Returns whether this reader rejects non-canonical LEB128 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> BufferedZigZagReader<R, NonStrict>

where R: Read,

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

Reads a ZigZag i8.

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

Reads a ZigZag i16.

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

Reads a ZigZag i32.

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

Reads a ZigZag i64.

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

Reads a ZigZag i128.

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

Reads a ZigZag isize.

impl<R> BufferedZigZagReader<R, Strict>

where R: Read,

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

Reads a ZigZag i8.

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

Reads a ZigZag i16.

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

Reads a ZigZag i32.

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

Reads a ZigZag i64.

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

Reads a ZigZag i128.

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

Reads a ZigZag isize.

Trait Implementations

impl<R, P> Read for BufferedZigZagReader<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 BufferedZigZagReader<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.