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};
use commonware_utils::NZUsize;

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, NZUsize!(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, NZUsize!(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: NonZeroUsize) -> Self

Creates a new Write that buffers up to capacity bytes of data to be appended to the tip of blob with the provided size.

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

Resize the blob to the given length.

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

Ensure all pending data is durably persisted.

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.