Struct EntryStream 

pub struct EntryStream { /* private fields */ }

EntryStream provides a streaming interface over an EntryHandle.

This struct allows reading large entries in chunks instead of loading the entire entry into memory. It is useful when working with entries larger than available RAM.

⚠️ Non Zero-Copy Warning

Unlike EntryHandle, this implementation performs memory copies. Each call to read() copies a portion of the entry into a user-provided buffer.

For zero-copy access, use EntryHandle::as_slice() instead.

Example Usage

use simd_r_drive::storage_engine::{DataStore, EntryHandle, EntryStream, traits::{DataStoreReader, DataStoreWriter}};
use std::io::Read;
use std::path::PathBuf;
use tempfile::tempdir;

let temp_dir = tempdir().expect("Failed to create temp dir");
let temp_path = temp_dir.path().join("test_storage.bin");

let data_store = DataStore::from(PathBuf::from(temp_path));

// Write some test data
data_store.write(b"test_key", b"test_data");
let entry_handle = data_store.read(b"test_key").unwrap().unwrap();

// Assume `entry_handle` is obtained from storage
let mut stream = EntryStream::from(entry_handle);

let mut buffer = vec![0; 4096]; // Read in 4KB chunks
while let Ok(bytes_read) = stream.read(&mut buffer) {
    if bytes_read == 0 {
        break; // EOF
    }
    // Replace this with actual processing logic
    println!("Read {} bytes", bytes_read);
}

Trait Implementations

impl From<EntryHandle> for EntryStream

fn from(entry_handle: EntryHandle) -> Self

Converts an EntryHandle into an EntryStream.

This allows the entry’s data to be read incrementally instead of accessing the full slice in memory at once.

⚠️ Non Zero-Copy Warning

• Streaming reads require memory copies.
• If you need direct access to the full entry without copying, use EntryHandle::as_slice().

impl Read for EntryStream

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

• Returns Ok(0) on EOF (no more data).
• Reads up to buf.len() bytes from the entry.
• Moves the read position forward after each call.

⚠️ Non Zero-Copy Warning

• This method copies data from the memory-mapped file into the buffer.
• Use EntryHandle::as_slice() for zero-copy access.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

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

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

🔬This is a nightly-only experimental API. (read_array)

Read and return a fixed array of bytes from this source.