Struct DebugCheckingAllocator 

pub struct DebugCheckingAllocator<A>
where
    A: BStackAllocator<Error = Error>,
{ /* private fields */ }

Debug-only allocator wrapper that validates allocations and deallocations.

Wraps any allocator whose Allocated type is BStackOwnedSlice and whose Error is io::Error. Maintains in-memory sets of allocated and freed regions and validates every operation against them.

Panics

Panics if:

• A newly allocated region overlaps with an existing allocated region
• A reallocated region overlaps with an existing allocated region
• A region being freed overlaps with a previously freed region

These panics indicate bugs in the underlying allocator implementation or a double free in the calling code.

Thread Safety

The internal tracking sets are protected by a Mutex for internal bookkeeping, but allocation operations and tracking updates must not be assumed to be an atomic, cross-thread synchronization boundary. Concurrent use of this debug wrapper is therefore not supported unless the caller provides external synchronization.

Implementations

impl<A> DebugCheckingAllocator<A>

where A: BStackAllocator<Error = Error>,

pub fn new(inner: A) -> Self

Create a new DebugCheckingAllocator wrapping inner.

The allocator starts with empty tracking sets. If you’re reopening a file from a previous session and want to pre-populate those sets, use Self::with_state instead.

pub fn with_state( inner: A, allocated: impl IntoIterator<Item = Range<u64>>, freed: impl IntoIterator<Item = Range<u64>>, ) -> Self

Create a new DebugCheckingAllocator wrapping inner, with pre-populated tracking sets.

Use this when reopening a file from a previous session and you have metadata to reconstruct which regions were allocated or freed.

Panics

Panics if the initial state is inconsistent:

• Any two ranges within allocated overlap
• Any two ranges within freed overlap
• Any range in allocated overlaps with any range in freed

pub fn inner(&self) -> &A

Return a reference to the inner allocator.

pub fn into_inner(self) -> A

Consume this allocator and return the inner allocator.

Trait Implementations

impl<A> BStackAllocator for DebugCheckingAllocator<A>

where for<'b> A: 'static + BStackAllocator<Error = Error> + BStackAllocator<Allocated<'b> = BStackOwnedSlice<'b, A>>,

type Error = Error

The error type returned by alloc, realloc, dealloc, alloc_bulk, and dealloc_bulk.

type Allocated<'a> = BStackOwnedSlice<'a, DebugCheckingAllocator<A>> where Self: 'a

The handle type returned by alloc and realloc, and accepted by realloc and dealloc.

fn stack(&self) -> &BStack

Return a shared reference to the underlying BStack.

fn into_stack(self) -> BStack

Consume the allocator and return the underlying BStack.

fn alloc(&self, len: u64) -> Result<Self::Allocated<'_>>

Allocate len zero-initialised bytes.

fn realloc<'a>( &'a self, handle: BStackOwnedSlice<'a, Self>, new_len: u64, ) -> Result<BStackOwnedSlice<'a, Self>, BStackAllocError<'a, Self>>

Resize the region described by handle to new_len bytes.

fn dealloc<'a>( &'a self, handle: BStackOwnedSlice<'a, Self>, ) -> Result<(), BStackAllocError<'a, Self>>

Release the region described by handle.

fn len(&self) -> Result<u64>

Return the current logical length of the backing stack payload.

fn is_empty(&self) -> Result<bool>

Return true if the backing stack is empty.

impl<A> BStackBulkAllocator for DebugCheckingAllocator<A>

where for<'b> A: 'static + BStackBulkAllocator<Error = Error> + BStackAllocator<Allocated<'b> = BStackOwnedSlice<'b, A>>,

fn alloc_bulk( &self, lengths: impl AsRef<[u64]>, ) -> Result<Vec<Self::Allocated<'_>>>

Allocate slices with the given lengths in a single atomic operation.

fn dealloc_bulk<'a>( &'a self, handles: impl IntoIterator<Item = BStackOwnedSlice<'a, Self>>, ) -> Result<(), BStackBulkAllocError<'a, Self>>

Deallocate multiple handles in a single atomic operation.

impl<A> Debug for DebugCheckingAllocator<A>

where A: BStackAllocator<Error = Error> + Debug,

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

Formats the value using the given formatter.