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, slice_ptr_len)]

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

let mut alloc = Chunk::<_, 64>(System);
let ptr = alloc.alloc(Layout::new::<[u8; 16]>())?;
assert_eq!(ptr.len() % 64, 0);
assert!(ptr.len() >= 64);

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

#![feature(slice_ptr_get)]

let new_ptr = unsafe {
    alloc.grow(
        ptr.as_non_null_ptr(),
        Layout::new::<[u8; 16]>(),
        Layout::new::<[u8; 24]>(),
    )?
};

assert_eq!(ptr, new_ptr);

This can be enforced by using ReallocateInPlace::grow_in_place.

use alloc_compose::ReallocateInPlace;

let len = unsafe {
    alloc.grow_in_place(
        ptr.as_non_null_ptr(),
        Layout::new::<[u8; 24]>(),
        Layout::new::<[u8; 32]>(),
    )?
};

assert_eq!(len % 64, 0);
assert!(len >= 64);

Trait Implementations

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

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

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

Attempts to allocate a block of memory.

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

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

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

pub unsafe fn grow(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

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

Attempts to extend the memory block.

pub unsafe fn grow_zeroed(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

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

pub unsafe fn shrink(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<NonNull<[u8]>, AllocError>

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

Attempts to shrink the memory block.

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

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

Deallocates the memory referenced by ptr.

pub fn by_ref(&self) -> &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>

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

Returns a copy of the value.

pub 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>

pub 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>

pub 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> where
    Self: SizeIsPowerOfTwo, 

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

Returns if the allocator owns the passed memory.

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

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

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

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

This method tests for !=.

impl<A, const SIZE: usize> ReallocateInPlace for Chunk<A, SIZE> where
    Self: SizeIsPowerOfTwo, 

pub unsafe default fn grow_in_place(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<usize, AllocError>

Attempts to extend the memory block.

pub unsafe default fn grow_in_place_zeroed(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<usize, AllocError>

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

pub unsafe default fn shrink_in_place(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<usize, AllocError>

Attempts to shrink the memory block.

impl<A: ReallocateInPlace, const SIZE: usize> ReallocateInPlace for Chunk<A, SIZE> where
    Self: SizeIsPowerOfTwo, 

pub unsafe fn grow_in_place(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<usize, AllocError>

Attempts to extend the memory block.

pub unsafe fn grow_in_place_zeroed(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<usize, AllocError>

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

pub unsafe fn shrink_in_place(
    &self,
    ptr: NonNull<u8>,
    old_layout: Layout,
    new_layout: Layout
) -> Result<usize, AllocError>

Attempts to shrink the memory block.

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

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