Struct ChainAllocator 

pub struct ChainAllocator<A, F> { /* private fields */ }

A ChainAllocator<A> create a new allocator of type A when the existing allocators of this type are exausted.

It can be useful when used with a LinearAllocator for example. When all of its memory is used, the ChainAllocator will create a new one. This is useful when you want to use fixed-sized allocators but you’re worried that your program will run out of memory.

There’s some overhead when using the ChainAllocator. Currently, every allocation has an extra pointer that refers to the allocator, to make deallocation possible. Also the allocators themselves are allocated using the Box.

Usage:

#![cfg_attr(not(feature = "stable"), feature(allocator_api))]
#[cfg(feature="vec")]
{
    use core::mem::size_of;

    use piece::vec::Vec;
    use piece::LinearAllocator;
    use piece::ChainAllocator;

    // Make room for the allocator pointer
    let chain_allocator = ChainAllocator::new(|| {
        LinearAllocator::with_capacity(32 * size_of::<i32>() + size_of::<*const ()>())
    });

    // Create two vectors that fills the whole `LinearAllocator` so
    // each `Vec` creates a new allocator
    let mut vec1 = Vec::with_capacity_in(32, &chain_allocator);
    let mut vec2 = Vec::with_capacity_in(32, &chain_allocator);

    vec1.extend_from_slice(&[1, 2, 3, 4, 5]);
    vec2.extend_from_slice(&[6, 7, 8, 9, 10]);

    assert_eq!(vec1, &[1, 2, 3, 4, 5]);
    assert_eq!(vec2, &[6, 7, 8, 9, 10]);

    assert_eq!(2, chain_allocator.allocator_count());
}

Implementations

impl<A, F> ChainAllocator<A, F>

where F: Fn() -> A,

pub const fn new(allocator_factory: F) -> Self

Creates a empty ChainAllocator<A>. allocator_factory should create a fresh allocator.

pub fn allocator_count(&self) -> usize

Returns the number of allocators created by this ChainAllocator<A>.

Trait Implementations

impl<A, F> Allocator for ChainAllocator<A, F>

where A: Allocator, F: Fn() -> A,

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

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

Attempts to allocate a block of memory.

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

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

Deallocates the memory referenced by ptr.

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.

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.

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.

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

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

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

fn by_ref(&self) -> &Self

where Self: Sized,

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

Creates a “by reference” adapter for this instance of Allocator.

impl<A, F> Drop for ChainAllocator<A, F>

fn drop(&mut self)

Executes the destructor for this type.

impl<A: Send, F> Send for ChainAllocator<A, F>