Struct Read 

pub struct Read<B: Blob> { /* private fields */ }

A reader that buffers content from a Blob to optimize the performance of a full scan of contents.

Example

use commonware_utils::NZUsize;
use commonware_runtime::{Runner, buffer::Read, Blob, Error, Storage, deterministic};

let executor = deterministic::Runner::default();
executor.start(|context| async move {
    // Open a blob and add some data (e.g., a journal file)
    let (blob, size) = context.open("my_partition", b"my_data").await.expect("unable to open blob");
    let data = b"Hello, world! This is a test.".to_vec();
    let size = data.len() as u64;
    blob.write_at(data, 0).await.expect("unable to write data");

    // Create a buffer
    let buffer = 64 * 1024;
    let mut reader = Read::new(blob, size, NZUsize!(buffer));

    // Read data sequentially
    let mut header = [0u8; 16];
    reader.read_exact(&mut header, 16).await.expect("unable to read data");
    println!("Read header: {:?}", header);

    // Position is still at 16 (after header)
    assert_eq!(reader.position(), 16);
});

Implementations

impl<B: Blob> Read<B>

pub fn new(blob: B, blob_size: u64, buffer_size: NonZeroUsize) -> Self

Creates a new Read that reads from the given blob with the specified buffer size.

Panics

Panics if buffer_size is zero.

pub fn buffer_remaining(&self) -> usize

Returns how many valid bytes are remaining in the buffer.

pub fn blob_remaining(&self) -> u64

Returns how many bytes remain in the blob from the current position.

pub fn blob_size(&self) -> u64

Returns the number of bytes in the blob, as provided at construction.

pub async fn read_exact( &mut self, buf: &mut [u8], size: usize, ) -> Result<(), Error>

Reads exactly size bytes into the provided buffer. Returns an error if not enough bytes are available.

Panics

Panics if size is greater than the length of buf.

pub fn position(&self) -> u64

Returns the current absolute position in the blob.

pub fn seek_to(&mut self, position: u64) -> Result<(), Error>

Repositions the buffer to read from the specified position in the blob.

pub async fn resize(self, len: u64) -> Result<(), Error>

Resizes the blob to the specified len and syncs the blob.

This may be useful if reading some blob after unclean shutdown.