Struct alloc_compose::SegregateAlloc

pub struct SegregateAlloc<Small, Large> {
    pub small: Small,
    pub large: Large,
    // some fields omitted
}

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> AllocRef for SegregateAlloc<Small, Large> where
    Small: AllocRef,
    Large: AllocRef, 

fn alloc(
    &mut self,
    layout: Layout,
    init: AllocInit
) -> Result<MemoryBlock, AllocErr>

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

Attempts to allocate a block of memory.

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,
    placement: ReallocPlacement,
    init: AllocInit
) -> Result<MemoryBlock, AllocErr>

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

Attempts to extend the memory block.

unsafe fn shrink(
    &mut self,
    ptr: NonNull<u8>,
    layout: Layout,
    new_size: usize,
    placement: ReallocPlacement
) -> Result<MemoryBlock, 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> Clone for SegregateAlloc<Small, Large>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Small: Copy, Large: Copy> Copy for SegregateAlloc<Small, Large>

impl<Small: Debug, Large: Debug> Debug for SegregateAlloc<Small, Large>

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

Formats the value using the given formatter.

impl<Small, Large> Owns for SegregateAlloc<Small, Large> where
    Small: Owns,
    Large: Owns, 

fn owns(&self, memory: MemoryBlock) -> bool

Returns if the allocator owns the passed MemoryBlock.