Struct ChainAllocator 

pub struct ChainAllocator<A: Allocator + Clone> { /* private fields */ }

ChainAllocator 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.

ChainAllocator creates a new LinearAllocator when the current one doesn’t have enough space for the requested allocation, and then links the new LinearAllocator to the previous one, creating a chain. This is where its name comes from.

Implementations

impl<A: Allocator + Clone> ChainAllocator<A>

pub const CHAIN_NODE_OVERHEAD: usize

The amount of bytes used by the ChainAllocator at the start of each chunk of the chain for bookkeeping.

pub const fn new_in(chunk_size_hint: usize, allocator: A) -> Self

Creates a new ChainAllocator. The chunk_size_hint is used as a size hint when creating new chunks of the chain. Note that the ChainAllocator will use some bytes at the beginning of each chunk of the chain. The number of bytes is Self::CHAIN_NODE_OVERHEAD. Keep this in mind when sizing your hint if you are trying to be precise, such as making sure a specific object fits.

pub fn used_bytes(&self) -> usize

Get the number of bytes allocated, including bytes for overhead. It does not count space it could allocate still, such as unused space at the end of the top node in the chain. It does count unallocated space at the end of previous nodes in the chain.

pub fn reserved_bytes(&self) -> usize

Get the number of bytes allocated by the underlying allocators for this chain. 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

Can the requested layout be allocated without requesting more from the underlying allocator.

Trait Implementations

impl<A: Allocator + Clone> Allocator for ChainAllocator<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 + Clone> Drop for ChainAllocator<A>

fn drop(&mut self)

Executes the destructor for this type.

impl<A: Allocator + Clone> Send for ChainAllocator<A>