lio::buf

Struct LentBuf

pub struct LentBuf<'a> { /* private fields */ }

Expand description

A borrowed buffer from a BufStore pool.

This buffer is automatically returned to the pool when dropped. It implements BufLike and can be used for I/O operations without allocating new memory.

Make sure to drop. Doing any std::mem::forget will lead to bad things.

Implementations§

Source §

impl<'a> LentBuf<'a>

Source

pub fn zeroize(&mut self)

Available on crate feature zeroize only.

Securely erases the buffer contents and resets position/length.

§When to Use

Call this method explicitly when you want to ensure sensitive data is cleared before the buffer is returned to the pool. Note that zeroize() is automatically called in the Drop implementation when the zeroize feature is enabled, so manual calls are typically only needed for early cleanup.

§Security Properties

Guarantees memory is overwritten (compiler cannot optimize away)
Clears the full buffer capacity (4096 bytes), not just the valid data range
Resets pos and len to 0
Uses zeroize::Zeroize trait for secure erasure

§Performance

This is equivalent to a 4096-byte memset(0) operation. For most use cases, the overhead is negligible compared to I/O costs.

§Example

let pool = BufStore::default();
let mut buf = pool.get();

// Read sensitive data (e.g., password)
// ... perform I/O operations ...

// Explicitly clear before continuing to use the buffer
buf.zeroize();

// Buffer is now zeroed and reset
assert_eq!(buf.as_ref().len(), 0);

Source §

impl<'a> LentBuf<'a>

Source

pub fn chunks(&self, chunk_size: usize) -> Chunks<'_, u8>

Returns an iterator over chunk_size chunks of the buffer.

The last chunk may be shorter if the buffer length is not evenly divisible.

§Panics

Panics if chunk_size is 0.

Source

pub fn windows(&self, window_size: usize) -> Windows<'_, u8>

Returns an iterator over overlapping windows of window_size.

Each window overlaps with the previous by window_size - 1 bytes.

§Panics

Panics if window_size is 0 or greater than buffer length.

Trait Implementations§

Source §

impl<'a> AsRef<[u8]> for LentBuf<'a>

Source §

fn as_ref(&self) -> &[u8] ⓘ

Converts this type into a shared reference of the (usually inferred) input type.

Source §

impl<'a> Buf for LentBuf<'a>

Available on crate feature bytes only.

Implementation of bytes::Buf for LentBuf.

Allows LentBuf to be used with the bytes crate ecosystem. The buffer’s valid data is from pos..len, where len is set by deinit() and pos tracks how much has been consumed via advance().

This implementation uses a position offset instead of copying data, making advance() a zero-copy operation.

§Example

use bytes::Buf;

let store = BufStore::default();
let mut buf = store.try_get().unwrap();
// ... fill buffer with data and call deinit(n) ...

// Use as bytes::Buf - all operations are zero-copy
let byte = buf.get_u8();
let bytes = buf.copy_to_bytes(4);

Source §

fn remaining(&self) -> usize

Returns the number of bytes between the current position and the end of the buffer. Read more

Source §

fn chunk(&self) -> &[u8] ⓘ

Returns a slice starting at the current position and of length between 0 and Buf::remaining(). Note that this can return a shorter slice (this allows non-continuous internal representation). Read more

Source §