Struct Stream 

pub struct Stream<'index, Reader> { /* private fields */ }

A stream which can be used to convert between offsets and line-column locations.

Index is a mutable reference to ensure that we can still refer to the index after consuming the whole Stream.

Implementations

impl<'index, R> Stream<'index, R>

pub fn new(reader: R, index: &'index mut Index) -> Self

pub fn get_ref(&self) -> &R

pub fn base(&self) -> usize

pub fn query(&self) -> Query<'_>

Immutable query to further query offsets and line-column locations

pub fn get_index(&self) -> &Index

impl<'index, R: Read> Stream<'index, R>

pub fn read_len(&self) -> usize

Read length

pub fn locate(&mut self, offset: Offset, buf: &mut [u8]) -> Result<ZeroBased>

Locate the (line, column) position for a given byte offset.

NOTE: this method may cause extra reading when the offset input cannot find a location.

This method first resolves the line index via [locate_line], then computes the column by subtracting the starting offset of that line.

Parameters

• offset: The target byte offset.
• buf: A temporary buffer used for incremental reading.

Returns

• Ok(ZeroBased(line, column)) if the offset is within bounds.
• Err if the offset exceeds EOF (propagated from [locate_line]).

Invariants

• The internal index always contains a valid starting offset for every line.
• Therefore, line_offset(line) must succeed for any valid line.

Notes

• Both line and column are zero-based.
• Column is computed in bytes, not characters (UTF-8 aware handling is not performed here).

pub fn locate_line(&mut self, offset: Offset, buf: &mut [u8]) -> Result<usize>

Locate the line index for a given byte offset.

This method performs an incremental lookup: it first queries the existing line index, and if the offset is not covered, it reads more data and extends the index. This method may cause extra reading when the offset input cannot find a location.

Invariants

• The internal index is non-empty and ends with a sentinel EOF offset.

Errors

Returns an error if offset exceeds EOF.

pub fn encode( &mut self, line_index: ZeroBased, buf: &mut [u8], ) -> Result<Offset>

Encode a (line, column) location into a byte Offset.

This method may incrementally extend the internal line index by reading additional data if the requested line is not yet available.

Behavior

• If the line is already indexed, the offset is computed directly.
• Otherwise, more data is read and the index is extended until the line becomes available or EOF is reached.

Returns

• Ok(offset) if the position can be resolved.
• Err if the line index exceeds EOF.

Notes

• Column is interpreted as a byte offset relative to the start of the line.
• This method does not validate whether the column lies within the bounds of the line.

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

Drain the reader, consume the reader

Trait Implementations

impl<'index, Reader: Debug> Debug for Stream<'index, Reader>

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

Formats the value using the given formatter.

impl<'index, R: Read> Read for Stream<'index, R>

You can use Stream as a normal io::Read and recording index at the same time.

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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.