Struct BufferedReadAt 

pub struct BufferedReadAt<R: Read> { /* private fields */ }

ReadAt over a sequential std::io::Read stream, buffered per a BufferPolicy.

Buffering manufactures the seeks the stream cannot provide, at an explicit price: a windowed source fails a far-back read, a spool fails past its cap. It never silently grows or returns wrong bytes.

Implementations

impl<R: Read> BufferedReadAt<R>

pub fn new(reader: R, policy: BufferPolicy) -> Self

Create a buffered source over reader with policy.

pub fn watermark(&self) -> u64

Bytes consumed from the underlying reader so far.

pub fn retained_bytes(&self) -> usize

Payload bytes retained for later random/backtrack reads. Excludes the caller’s destination and fixed stack scratch used while skipping.

Trait Implementations

impl<R: Read> ReadAt for BufferedReadAt<R>

fn len(&mut self) -> Result<u64, Self::Error>

Consumes the stream to EOF. Under a window policy the bytes are evicted as they pass, so the length is known but early bytes are gone; under a spool they are retained up to the cap. At the exact spool cap, a one-byte stack probe distinguishes EOF from excess input. Excess consumes that one byte and makes subsequent operations fail; retained payload never exceeds the cap. This is not a total-input-byte limit.

fn read_at(&mut self, offset: u64, out: &mut [u8]) -> Result<usize, Self::Error>

Reads forward only as far as offset + out.len(): the end of the stream is found by a short read, never by consuming it to learn the length.

type Error = StdSourceError

The source-specific error type.

fn read_exact_at( &mut self, offset: u64, out: &mut [u8], ) -> Result<(), Self::Error>

Fill out with the bytes at offset. Fails rather than returning a short read.

fn len_hint(&self) -> Option<u64>

Total length if it is known without reading ahead. Default None.

fn read_many_at( &mut self, reqs: &mut [(u64, &mut [u8])], ) -> Result<(), Self::Error>

Fill each buffer from its offset. The default serves requests in the order given; concurrent sources override to overlap them.

fn is_empty(&mut self) -> Result<bool, Self::Error>

Whether the source is empty.

fn as_slice(&self) -> Option<&[u8]>

The whole source as one slice, when it is already in memory. Drivers and codecs use it to read without copying. Default None.