Struct ReusedBuffer 

pub struct ReusedBuffer<T: 'static> { /* private fields */ }

A truly-pooled buffer: holds the actual pooled allocation without copying.

When dropped (or via release_to_pool), the buffer is returned to the global pool. Use into_vec(len) to take ownership as a Vec<T>.

Implementations

impl<T: 'static> ReusedBuffer<T>

pub fn as_uninit_slice_mut(&mut self) -> &mut [MaybeUninit<T>]

Returns a mutable view of the buffer as uninitialized elements.

pub fn capacity(&self) -> usize

Capacity in elements (not bytes).

pub fn as_ptr_raw(&self) -> *mut T

Raw pointer access — primarily for tests to verify address identity.

pub fn into_vec(self, len: usize) -> Vec<T>

where T: Copy,

Consume self and transfer ownership of the allocation to a Vec<T>.

The caller must guarantee len <= self.capacity() and that the first len elements have been initialized.

The Vec now owns the memory and will free it on drop; it is NOT returned to the pool.

Custom alignment

A Vec<T> always deallocates with Layout::array::<T>(), i.e. alignment align_of::<T>(). A buffer acquired through GlobalMemoryPool::acquire_uninit_aligned with a larger alignment therefore cannot hand its allocation to a Vec — that would be a mismatched-Layout deallocation (undefined behaviour). Such buffers are copied into a fresh Vec instead and the over-aligned allocation is returned to the pool, where it can still be reused.

pub fn release_to_pool(self)

Consume self and return the buffer to the pool.

If the pool is gone (Arc was dropped), the allocation is freed instead.

Trait Implementations

impl<T: 'static> Drop for ReusedBuffer<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T: Send + 'static> Send for ReusedBuffer<T>

SAFETY: ReusedBuffer<T> owns a unique allocation; it is safe to send across threads when T: Send.