Struct TrackedAllocation 

pub struct TrackedAllocation<T> { /* private fields */ }

A tracked allocation that stores its layout for safe deallocation.

This wrapper ensures that memory is deallocated with the same layout that was used for allocation, preventing undefined behavior.

Example

use ruvector_security::TrackedAllocation;

// Allocate memory for 100 f32 values
let mut alloc = TrackedAllocation::<f32>::new(100).unwrap();

// Write data
unsafe {
    for i in 0..100 {
        *alloc.as_mut_ptr().add(i) = i as f32;
    }
}

// Memory is automatically deallocated when `alloc` is dropped

Implementations

impl<T> TrackedAllocation<T>

pub fn new(count: usize) -> SecurityResult<Self>

Allocate memory for count elements of type T.

Errors

Returns an error if:

• count is zero
• The allocation size overflows
• The allocator fails

pub fn new_zeroed(count: usize) -> SecurityResult<Self>

Allocate and zero-initialize memory.

pub fn as_ptr(&self) -> *const T

Get a raw pointer to the allocation.

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

Get a mutable raw pointer to the allocation.

pub fn len(&self) -> usize

Get the number of elements.

pub fn is_empty(&self) -> bool

Check if the allocation is empty (always false for valid allocations).

pub fn layout(&self) -> Layout

Get the layout used for allocation.

pub unsafe fn as_slice(&self) -> &[T]

Convert to a slice.

Safety

The caller must ensure the memory has been properly initialized.

pub unsafe fn as_slice_mut(&mut self) -> &mut [T]

Convert to a mutable slice.

Safety

The caller must ensure the memory has been properly initialized.

pub fn copy_from_slice(&mut self, src: &[T])

where T: Copy,

Copy data from a slice into the allocation.

Panics

Panics if the slice length doesn’t match the allocation length.

pub fn into_raw_parts(self) -> (*mut T, Layout, usize)

Take ownership and return raw parts.

After calling this, the caller is responsible for deallocation. Use TrackedAllocation::from_raw_parts to reconstruct.

pub unsafe fn from_raw_parts( ptr: *mut T, layout: Layout, len: usize, ) -> Option<Self>

Reconstruct from raw parts.

Safety

The caller must provide parts from a previous into_raw_parts call with matching type T.

Trait Implementations

impl<T> Drop for TrackedAllocation<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Send> Send for TrackedAllocation<T>

impl<T: Sync> Sync for TrackedAllocation<T>