Struct Write

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

A writer that buffers content to a Blob to optimize the performance of appending or updating data.

Example

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

let executor = deterministic::Runner::default();
executor.start(|context| async move {
    // Open a blob for writing
    let (blob, size) = context.open("my_partition", b"my_data").await.expect("unable to open blob");
    assert_eq!(size, 0);

    // Create a buffered writer with 16-byte buffer
    let mut blob = Write::new(blob, 0, 16);
    blob.write_at(b"hello".to_vec(), 0).await.expect("write failed");
    blob.sync().await.expect("sync failed");

    // Write more data in multiple flushes
    blob.write_at(b" world".to_vec(), 5).await.expect("write failed");
    blob.write_at(b"!".to_vec(), 11).await.expect("write failed");
    blob.sync().await.expect("sync failed");

    // Read back the data to verify
    let (blob, size) = context.open("my_partition", b"my_data").await.expect("unable to reopen blob");
    let mut reader = Read::new(blob, size, 8);
    let mut buf = vec![0u8; size as usize];
    reader.read_exact(&mut buf, size as usize).await.expect("read failed");
    assert_eq!(&buf, b"hello world!");
});

Implementations

impl<B: Blob> Write<B>

pub fn new(blob: B, size: u64, capacity: usize) -> Self

Creates a new Write that buffers writes to a Blob with the provided size and buffer capacity.

Panics

Panics if capacity is zero.

pub async fn size(&self) -> u64

Returns the current logical size of the blob including any buffered data.

This represents the total size of data that would be present after flushing.

Trait Implementations

impl<B: Blob> Blob for Write<B>

async fn read_at( &self, buf: impl Into<StableBuf> + Send, offset: u64, ) -> Result<StableBuf, Error>

Read from the blob at the given offset.

async fn write_at( &self, buf: impl Into<StableBuf> + Send, offset: u64, ) -> Result<(), Error>

Write buf to the blob at the given offset.

async fn truncate(&self, len: u64) -> Result<(), Error>

Truncate the blob to the given length.

async fn sync(&self) -> Result<(), Error>

Ensure all pending data is durably persisted.

async fn close(self) -> Result<(), Error>

Close the blob.

impl<B: Clone + Blob> Clone for Write<B>

fn clone(&self) -> Write<B>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.