Struct BlockCacheReader 

pub struct BlockCacheReader<R> { /* private fields */ }

Implementations

impl<R: RangeReader> BlockCacheReader<R>

pub fn new(inner: R, block: u64) -> Self

Wrap inner, fetching block-aligned blocks (clamped to ≥ 4 KiB) and keeping at most DEFAULT_CACHE_CAP bytes of them resident.

pub fn with_cache_cap(self, cap: u64) -> Self

Override the resident-byte cap. The cap is enforced between reads: a single read spanning more than cap bytes of blocks is still served exactly (its blocks are resident while it assembles) and the cache is trimmed back under the cap right after. u64::MAX disables eviction.

pub fn cached_bytes(&self) -> u64

Bytes currently resident in the cache (for stats and tests).

Trait Implementations

impl<R: RangeReader> RangeReader for BlockCacheReader<R>

fn len(&self) -> u64

Total resource length in bytes.

fn concurrency(&self) -> usize

How many ranges this reader can usefully have in flight at once — the planner’s hint for probe-vs-scan and batch-size decisions (a phone’s serial sync-XHR reader reports 1; the CLI’s threaded HTTP client and the browser’s concurrent-fetch variants report their fan-out). Purely advisory: correctness never depends on it. Defaults to 1 (sequential).

fn read_at(&self, offset: u64, len: u64) -> Result<Vec<u8>>

Read len bytes starting at offset. Implementations should error on an out-of-bounds range rather than truncating.

fn read_many(&self, ranges: &[(u64, u64)]) -> Result<Vec<Vec<u8>>>

Read several (offset, len) ranges, returning each range’s bytes in request order. These ranges are independent, so a reader whose backing store is high-latency but parallelizable (an HTTP client) overrides this to issue the reads concurrently — turning N round trips into ~N/P. The default fetches them sequentially. Any range failing fails the batch.

fn is_empty(&self) -> bool

True when the resource is empty.