Struct Append 

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

A Blob wrapper that supports write-cached appending of data, with checksums for data integrity and page cache managed caching.

Implementations

impl<B: Blob> Append<B>

pub async fn new( blob: B, original_blob_size: u64, capacity: usize, cache_ref: CacheRef, ) -> Result<Self, Error>

Create a new Append wrapper of the provided blob that is known to have blob_size underlying physical bytes, using the provided cache_ref for read caching, and a write buffer with capacity capacity. Rewinds the blob if necessary to ensure it only contains checksum-validated data.

pub async fn append(&self, buf: &[u8]) -> Result<(), Error>

Append all bytes in buf to the tip of the blob.

pub async fn size(&self) -> u64

Returns the logical size of the blob. This accounts for both written and buffered data.

pub async fn read_at(&self, offset: u64, len: usize) -> Result<IoBufs, Error>

Read exactly len immutable bytes starting at offset.

pub async fn read_up_to( &self, logical_offset: u64, len: usize, bufs: impl Into<IoBufMut> + Send, ) -> Result<(IoBufMut, usize), Error>

Reads up to buf.len() bytes starting at logical_offset, but only as many as are available.

This is useful for reading variable-length prefixes (like varints) where you want to read up to a maximum number of bytes but the actual data might be shorter.

Returns the buffer (truncated to actual bytes read) and the number of bytes read. Returns an error if no bytes are available at the given offset.

pub async fn read_into( &self, buf: &mut [u8], logical_offset: u64, ) -> Result<(), Error>

Reads bytes starting at logical_offset into buf.

This method allows reading directly into a mutable slice without taking ownership of the buffer or requiring a specific buffer type.

pub async fn replay( &self, buffer_size: NonZeroUsize, ) -> Result<Replay<B>, Error>

Flushes any buffered data, then returns a Replay for the underlying blob.

The returned replay can be used to sequentially read all pages from the blob while ensuring all data passes integrity verification. CRCs are validated but not included in the output.

impl<B: Blob> Append<B>

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

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

Resize the blob to the provided logical size.

This truncates the blob to contain only size logical bytes. The physical blob size will be adjusted to include the necessary CRC records for the remaining pages.

Warning

• Concurrent mutable operations (append, resize) are not supported and will cause data loss.
• Concurrent readers which try to read past the new size during the resize may error.
• The resize is not guaranteed durable until the next sync.

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.