Struct LinearAllocator 

pub struct LinearAllocator<A: Allocator> { /* private fields */ }

LinearAllocator is an arena allocator, meaning that deallocating individual allocations made by this allocator does nothing. Instead, the whole backing memory is dropped at once. Destructors for these objects are not called automatically and must be done by the caller if it’s necessary.

Once the slice of memory that underpins the LinearAllocator has been allocated, allocations will begin to fail. It will not find new memory to back allocations.

Implementations

impl<A: Allocator> LinearAllocator<A>

pub fn new_in(layout: Layout, allocator: A) -> Result<Self, AllocError>

Creates a new LinearAllocator by requesting the layout from the provided allocator. Note that if the allocation is over-sized, meaning it’s larger than the requested layout.size(), then the LinearAllocator will utilize this excess.

pub fn used_bytes(&self) -> usize

Get the number of bytes allocated.

pub fn reserved_bytes(&self) -> usize

Get the number of bytes allocated by the underlying allocator. This number is greater than or equal to Self::used_bytes.

pub fn remaining_capacity(&self) -> usize

Gets the number of bytes that can be allocated without requesting more from the underlying allocator.

pub fn has_capacity_for(&self, layout: Layout) -> bool

Determine if the given layout will fit in the current allocator

Trait Implementations

impl<A: Allocator> Allocator for LinearAllocator<A>

fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

Attempts to allocate a block of memory.

unsafe fn deallocate(&self, _ptr: NonNull<u8>, _layout: Layout)

Deallocates the memory referenced by ptr.

fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>

Behaves like allocate, but also ensures that the returned memory is zero-initialized.

unsafe fn grow( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, ) -> Result<NonNull<[u8]>, AllocError>

Attempts to extend the memory block.

unsafe fn grow_zeroed( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, ) -> Result<NonNull<[u8]>, AllocError>

Behaves like grow, but also ensures that the new contents are set to zero before being returned.

unsafe fn shrink( &self, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout, ) -> Result<NonNull<[u8]>, AllocError>

Attempts to shrink the memory block.

fn by_ref(&self) -> &Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Allocator.

impl<A: Allocator> Drop for LinearAllocator<A>

fn drop(&mut self)

Executes the destructor for this type.

impl<A: Allocator> Send for LinearAllocator<A>