Struct alloc_compose::Chunk

pub struct Chunk<A, const SIZE: usize>(pub A);

Allocate memory with a multiple size of the provided chunk size.

Examples

#![feature(allocator_api)]

use alloc_compose::Chunk;
use std::alloc::{AllocInit, AllocRef, Layout, System};

let mut data = [0; 64];
let mut alloc = Chunk::<_, 64>(System);
let memory = alloc.alloc(Layout::new::<[u8; 16]>(), AllocInit::Uninitialized)?;
assert_eq!(memory.size % 32, 0);
assert!(memory.size >= 32);

When growing or shrinking the memory, Chunk will try to alter the memory in place before delegating to the underlying allocator.

use std::alloc::ReallocPlacement;
let memory = unsafe {
    alloc.grow(
        memory.ptr,
        Layout::new::<[u8; 16]>(),
        24,
        ReallocPlacement::InPlace,
        AllocInit::Uninitialized,
    )?
};
assert_eq!(memory.size % 32, 0);
assert!(memory.size >= 32);

Trait Implementations

impl<A: AllocRef, const SIZE: usize> AllocRef for Chunk<A, SIZE>

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<A: Clone, const SIZE: usize> Clone for Chunk<A, SIZE>

fn clone(&self) -> Chunk<A, SIZE>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Copy, const SIZE: usize> Copy for Chunk<A, SIZE>

impl<A: Debug, const SIZE: usize> Debug for Chunk<A, SIZE>

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

Formats the value using the given formatter.

impl<A: Default, const SIZE: usize> Default for Chunk<A, SIZE>

fn default() -> Chunk<A, SIZE>

Returns the "default value" for a type.

impl<A: Eq, const SIZE: usize> Eq for Chunk<A, SIZE>

impl<A: Owns, const SIZE: usize> Owns for Chunk<A, SIZE>

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

Returns if the allocator owns the passed MemoryBlock.

impl<A: PartialEq, const SIZE: usize> PartialEq<Chunk<A, SIZE>> for Chunk<A, SIZE>

fn eq(&self, other: &Chunk<A, SIZE>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Chunk<A, SIZE>) -> bool

This method tests for !=.

impl<A, const SIZE: usize> StructuralEq for Chunk<A, SIZE>

impl<A, const SIZE: usize> StructuralPartialEq for Chunk<A, SIZE>