Struct BufferedInput 

pub struct BufferedInput<I>
where
    I: Input,
    I::Item: Copy + Default,
{ /* private fields */ }

Buffered unit input over a wrapped input source.

This type owns a wrapped input object and an internal unit buffer. It keeps unread units in buffer[position..limit] so callers can inspect or consume the current unit window before refilling it.

BufferedInput is deliberately unit-oriented. It performs no binary decoding, text decoding, or record parsing; higher-level stream adapters can build those concerns on top of Self::unread_slice, Self::unread_raw_parts, Self::ensure_available, and Self::read_into_unchecked. The type also implements BufRead for callers that want the standard buffered-read interface.

Implementations

impl<I> BufferedInput<I>

where I: Input, I::Item: Copy + Default,

pub fn new(inner: I) -> Self

Creates a buffered unit input with the default capacity.

Arguments

• inner - The input object wrapped by this buffer.

Returns

A new buffered unit input whose internal buffer has at least DEFAULT_BUFFER_CAPACITY units.

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

Creates a buffered unit input with at least the requested capacity.

The actual capacity is raised to 1 when the requested value is 0.

Arguments

• inner - The input object wrapped by this buffer.
• capacity - The requested internal buffer capacity, in units.

Returns

A new buffered unit input whose internal buffer capacity is capacity.max(1).

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

Returns a shared reference to the wrapped input object.

Returns

A shared reference to the inner input object.

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

Returns an exclusive reference to the wrapped input object.

Mutating the wrapped object directly may invalidate assumptions about units already buffered by this value.

Returns

An exclusive reference to the wrapped input object.

pub fn into_parts(self) -> (I, Vec<I::Item>)

Consumes this buffered input and returns the wrapped input object plus unread bytes.

This method performs no I/O. Units that have already been read from the wrapped input but not consumed by this buffered input are returned as the second tuple item.

Returns

The wrapped input object and a vector containing the unread buffered units in logical read order.

pub fn capacity(&self) -> usize

Returns the internal buffer capacity.

Returns

The total number of units that can be held by the internal buffer.

pub fn available(&self) -> usize

Returns the number of unread units currently buffered.

Returns

The length of buffer[position..limit], in units.

pub fn unread_slice(&self) -> &[I::Item]

Returns the currently buffered unread units.

Returns

The unread range buffer[position..limit].

pub fn unread_raw_parts(&self) -> (&[I::Item], usize, usize)

Returns raw unread-buffer parts for hot-path callers.

The returned slice is the full internal backing storage. index is the start of the unread unit window, and count is the number of unread units. Callers that need a slice can use &buffer[index..index + count]; callers that already validated bounds can pass buffer and index directly to indexed unchecked codecs.

Returns

The backing storage, the unread start index, and the unread unit count.

pub fn consume(&mut self, count: usize)

Advances the unread cursor by count units.

Parameters

• count - Number of currently unread units to consume.

Panics

Panics when count exceeds Self::available.

pub unsafe fn consume_unchecked(&mut self, count: usize)

Advances the unread cursor without checking bounds.

Parameters

• count - Number of currently unread bytes to consume.

Safety

The caller must guarantee that count <= self.available().

impl<I> BufferedInput<I>

where I: Input, I::Item: Copy + Default,

pub fn fill_more(&mut self) -> Result<bool>

Refills the internal buffer after preserving unread bytes.

Consumed bytes may be discarded, and unread bytes may be moved to the front of the buffer before the wrapped reader is called.

Returns

Ok(true) if at least one byte was appended, or Ok(false) at EOF.

Errors

Returns any non-interrupted I/O error produced by the wrapped reader.

pub fn fill_until(&mut self, count: usize) -> Result<bool>

Refills the buffer until at least count unread bytes are available.

This method may discard consumed bytes or move unread bytes to the front of the buffer before reading more data. It stops as soon as the unread window reaches count bytes or the wrapped reader reaches EOF.

Parameters

• count - Minimum number of unread bytes required.

Returns

Ok(true) if at least count unread bytes are buffered. Ok(false) means EOF was reached before the requested byte count became available.

Errors

Returns ErrorKind::InvalidInput when count exceeds the internal buffer capacity. Returns ErrorKind::InvalidData if the wrapped reader reports more bytes than the spare buffer range could hold. Returns any non-interrupted I/O error produced by the wrapped reader while refilling the buffer.

pub fn ensure_available(&mut self, count: usize) -> Result<()>

Ensures that at least count unread bytes are available.

Unlike Self::fill_until, this method treats EOF before the requested byte count as ErrorKind::UnexpectedEof. Any partial bytes buffered before EOF are consumed so callers observe the same logical position as a failed exact read.

Parameters

• count - Minimum number of unread bytes required.

Errors

Returns ErrorKind::UnexpectedEof if EOF is reached before count bytes are available. Returns ErrorKind::InvalidInput when count exceeds the internal buffer capacity. Returns ErrorKind::InvalidData if the wrapped reader reports more bytes than the spare buffer range could hold. Returns any non-interrupted I/O error produced by the wrapped reader while refilling the buffer.

pub unsafe fn read_into_unchecked( &mut self, output: &mut [I::Item], output_index: usize, count: usize, ) -> Result<usize>

Reads bytes through the internal buffer into an indexed output range.

If the internal buffer is empty and count is at least as large as the internal buffer capacity, the read is delegated directly to the wrapped reader to avoid an unnecessary copy. Otherwise, bytes are served from the internal buffer.

Arguments

• output - Destination storage that receives bytes.
• output_index - Start index inside output.
• count - Maximum number of bytes to read.

Returns

The number of bytes written into output[output_index..output_index + count]. A return value of 0 means that count was zero or EOF was reached before any bytes were read.

Errors

Returns any I/O error produced by the wrapped reader. Returns ErrorKind::InvalidData if the wrapped reader reports more bytes than the requested destination range could hold. Interrupted reads are retried when the method refills the internal buffer through read_more; direct delegated reads follow the wrapped reader’s own Read::read behavior.

Safety

The caller must guarantee that output_index..output_index + count is a valid range inside output and that the addition does not overflow.

Trait Implementations

impl<I> BufRead for BufferedInput<I>

where I: Input<Item = u8>,

fn fill_buf(&mut self) -> Result<&[u8]>

Returns the currently buffered unread bytes, refilling when empty.

fn consume(&mut self, amount: usize)

Consumes amount bytes from the unread byte window.

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

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

Checks if there is any data left to be read.

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

Reads all bytes into buf until the delimiter byte or EOF is reached.

fn skip_until(&mut self, byte: u8) -> Result<usize, Error>

Skips all bytes until the delimiter byte or EOF is reached.

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

Reads all bytes until a newline (the 0xA byte) is reached, and append them to the provided String buffer.

fn split(self, byte: u8) -> Split<Self>

where Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte.

fn lines(self) -> Lines<Self>

where Self: Sized,

Returns an iterator over the lines of this reader.

impl<I> Debug for BufferedInput<I>

where I: Input + Debug, I::Item: Copy + Default + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I> Read for BufferedInput<I>

where I: Input<Item = u8>,

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

Reads bytes through the internal buffer.

Arguments

• output - Destination slice that receives the bytes read.

Returns

The number of bytes written to output.

Errors

Returns any I/O error produced by the wrapped 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<I> Seek for BufferedInput<I>

where I: Input<Item = u8> + 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.