Struct OrderedPoolAllocator

pub struct OrderedPoolAllocator<'buf, T, const N: usize = { mem::size_of::<usize>() }> { /* private fields */ }

An allocator for T objects, with a block index of N bytes.

If N is 1, then blocks_capacity will be u8::MAX. If N is 2, then blocks_capacity will be u16::MAX.

Implementations

impl<'buf, T, const N: usize> OrderedPoolAllocator<'buf, T, N>

pub fn new_in(buf: &'buf mut [u8]) -> Self

pub unsafe fn allocate(&mut self) -> Result<NonNull<T>, AllocError>

Allocates a block and returns a pointer to the block.

This method will always prioritize reallocating an existing deallocated block over allocating a new block.

Safety

Behavior is undefined if the returned pointer points to an uninitialized instance of T when the allocator is dropped.

pub unsafe fn deallocate(&mut self, ptr: NonNull<T>)

Deallocates the block at the specified pointer.

Side effect: swaps the virtual block indices of the specified block with the last allocated virtual block.

Safety

Behavior is undefined if any of the following conditions are violated:

• ptr must point to an instance of T allocated by this allocator.

• ptr must not point to an instance of T that has already been dropped or deallocated by this allocator.

pub const fn len(&self) -> usize

pub const fn capacity(&self) -> usize

pub const fn is_empty(&self) -> bool

pub const fn is_full(&self) -> bool

pub fn sort_unstable_by<F>(&mut self, compare: F)

where F: FnMut(&MaybeUninit<T>, &MaybeUninit<T>) -> Ordering,

Trait Implementations

impl<T, const N: usize> Drop for OrderedPoolAllocator<'_, T, N>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, const N: usize> Index<usize> for OrderedPoolAllocator<'_, T, N>

type Output = MaybeUninit<T>

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, const N: usize> IndexMut<usize> for OrderedPoolAllocator<'_, T, N>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.