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_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, 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: usize) -> 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 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.

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 truncate(self, len: u64) -> Result<(), Error>

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

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