Struct FixedBlockMemory 

pub struct FixedBlockMemory { /* private fields */ }

Available on crate features test-util only.

A memory provider that uses fixed-size memory blocks.

Every memory capacity reservation is cut into into blocks of fixed size and delegated to the Rust global allocator, which provides the actual memory capacity.

This provider is meant for test scenarios where a specific memory block size is important, such as when testing edge cases of multi-block byte sequence handling. You can go down as low as 1 byte per block to simulate extreme memory fragmentation. All user code is expected to correctly operate with memory blocks of any size, including single-byte blocks.

Performance

This memory provider is a simple implementation that does not perform any pooling or performance optimization, so should not be used in real code.

Examples

Reserving memory returns capacity rounded up to the block size:

use std::num::NonZero;

use bytesbuf::BytesView;
use bytesbuf::mem::Memory;
use bytesbuf::mem::testing::FixedBlockMemory;

// Create a memory provider with 16-byte blocks.
let memory = FixedBlockMemory::new(NonZero::new(16).unwrap());

// Request 10 bytes - capacity is rounded up to 16 (one full block).
let buf = memory.reserve(10);
assert_eq!(buf.capacity(), 16);

// Request 20 bytes - capacity is rounded up to 32 (two full blocks).
let buf = memory.reserve(20);
assert_eq!(buf.capacity(), 32);

// Data spanning multiple blocks is split across slices.
let mut data = BytesView::copied_from_slice(b"Hello, world! This is a test!", &memory);
assert_eq!(data.len(), 29);
assert_eq!(data.first_slice().len(), 16); // First block is full.
data.advance(16);
assert_eq!(data.first_slice().len(), 13); // Remaining 13 bytes in second block.

Implementations

impl FixedBlockMemory

pub fn new(block_size: NonZero<BlockSize>) -> Self

Creates a new instance of the memory provider.

pub fn reserve(&self, min_bytes: usize) -> BytesBuf

Reserves at least min_bytes bytes of memory capacity.

The requested amount min_bytes is rounded up to the nearest multiple of the fixed block size.

Returns a BytesBuf that can be used to fill the reserved memory with data.

The memory reservation request will always be fulfilled, obtaining more memory from the operating system if necessary.

Zero-sized reservations

Reserving zero bytes of memory is a valid operation and will return a BytesBuf with zero bytes of capacity.

Panics

May panic if the operating system runs out of memory.

Trait Implementations

impl Clone for FixedBlockMemory

fn clone(&self) -> FixedBlockMemory

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FixedBlockMemory

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Memory for FixedBlockMemory

fn reserve(&self, min_bytes: usize) -> BytesBuf

Reserves at least min_bytes bytes of memory capacity.