Struct alloc_compose::Segregate

pub struct Segregate<Small, Large, const THRESHOLD: usize> {
    pub small: Small,
    pub large: Large,
}

Dispatches calls to AllocRef between two allocators depending on the size allocated.

All allocations smaller than or equal to threshold will be dispatched to Small. The others will go to Large.

Fields

small: Small

large: Large

Trait Implementations

impl<Small, Large, const THRESHOLD: usize> AllocAll for Segregate<Small, Large, THRESHOLD> where
    Small: AllocAll,
    Large: AllocAll, 

fn alloc_all(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr>

Attempts to allocate all of the memory the allocator can provide.

fn alloc_all_zeroed(
    &mut self,
    layout: Layout
) -> Result<NonNull<[u8]>, AllocErr>

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

fn dealloc_all(&mut self)

Deallocates all the memory the allocator had allocated.

fn capacity(&self) -> usize

Returns the total capacity available in this allocator.

fn capacity_left(&self) -> usize

Returns the free capacity left for allocating.

fn is_empty(&self) -> bool

Returns if the allocator is currently not holding memory.

fn is_full(&self) -> bool

Returns if the allocator has no more capacity left.

impl<Small, Large, const THRESHOLD: usize> AllocRef for Segregate<Small, Large, THRESHOLD> where
    Small: AllocRef,
    Large: AllocRef, 

fn alloc(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr>

🔬 This is a nightly-only experimental API. (allocator_api)

Attempts to allocate a block of memory.

fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr>

🔬 This is a nightly-only experimental API. (allocator_api)

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

unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout)

🔬 This is a nightly-only experimental API. (allocator_api)

Deallocates the memory referenced by ptr.

unsafe fn grow(
    &mut self,
    ptr: NonNull<u8>,
    layout: Layout,
    new_size: usize
) -> Result<NonNull<[u8]>, AllocErr>

🔬 This is a nightly-only experimental API. (allocator_api)

Attempts to extend the memory block.

unsafe fn grow_zeroed(
    &mut self,
    ptr: NonNull<u8>,
    layout: Layout,
    new_size: usize
) -> Result<NonNull<[u8]>, AllocErr>

🔬 This is a nightly-only experimental API. (allocator_api)

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

unsafe fn shrink(
    &mut self,
    ptr: NonNull<u8>,
    layout: Layout,
    new_size: usize
) -> Result<NonNull<[u8]>, AllocErr>

🔬 This is a nightly-only experimental API. (allocator_api)

Attempts to shrink the memory block.

fn by_ref(&mut self) -> &mut Self

🔬 This is a nightly-only experimental API. (allocator_api)

Creates a "by reference" adaptor for this instance of AllocRef.

impl<Small: Clone, Large: Clone, const THRESHOLD: usize> Clone for Segregate<Small, Large, THRESHOLD>

fn clone(&self) -> Segregate<Small, Large, THRESHOLD>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Small: Copy, Large: Copy, const THRESHOLD: usize> Copy for Segregate<Small, Large, THRESHOLD>

impl<Small: Debug, Large: Debug, const THRESHOLD: usize> Debug for Segregate<Small, Large, THRESHOLD>

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

Formats the value using the given formatter.

impl<Small, Large, const THRESHOLD: usize> Owns for Segregate<Small, Large, THRESHOLD> where
    Small: Owns,
    Large: Owns, 

fn owns(&self, ptr: NonNull<[u8]>) -> bool

Returns if the allocator owns the passed MemoryBlock.