Struct BumpScope 

pub struct BumpScope<'a, A = Global, S = BumpSettings>
where
    S: BumpAllocatorSettings,
{ /* private fields */ }

A bump allocation scope.

A BumpScope’s allocations are live for 'a, which is the lifetime of its associated BumpScopeGuard or scoped closure.

BumpScope has mostly same api as Bump.

This type is provided as a parameter to the closure of scoped, or created by BumpScopeGuard::scope. A Bump can also be turned into a BumpScope using as_scope, as_mut_scope or from / into.

Implementations

impl<A, S> BumpScope<'_, A, S>

where A: Allocator, S: BumpAllocatorSettings,

pub fn by_value(&mut self) -> BumpScope<'_, A, S>

Returns this &mut BumpScope as a BumpScope.

This requires allocating a chunk if none has been allocated yet.

This method exists so you can have BumpScope<'a> function parameters and struct fields instead of &'b mut BumpScope<'a> so you don’t have to deal with 'b.

It also enables more settings conversions since with_settings can do more than borrow_mut_with_settings.

Panics

Panics if the bump allocator is currently claimed.

Panics if the allocation fails.

pub fn try_by_value(&mut self) -> Result<BumpScope<'_, A, S>, AllocError>

Returns this &mut BumpScope as a BumpScope.

This requires allocating a chunk if none has been allocated yet.

This method exists so you can have BumpScope<'a> function parameters and struct fields instead of &'b mut BumpScope<'a> so you don’t have to deal with 'b.

It also enables more settings conversions since with_settings can do more than borrow_mut_with_settings.

Errors

Errors if the bump allocator is currently claimed.

Errors if the allocation fails.

impl<'a, A, S> BumpScope<'a, A, S>

where S: BumpAllocatorSettings,

pub fn stats(&self) -> Stats<'a, S>

Returns a type which provides statistics about the memory usage of the bump allocator.

pub fn as_mut_aligned<const NEW_MIN_ALIGN: usize>( &mut self, ) -> &mut BumpScope<'a, A, S::WithMinimumAlignment<NEW_MIN_ALIGN>>

where MinimumAlignment<NEW_MIN_ALIGN>: SupportedMinimumAlignment,

Mutably borrows BumpScope with a new minimum alignment.

This cannot decrease the alignment. Trying to decrease alignment will result in a compile error. You can use aligned or scoped_aligned to decrease the alignment.

When decreasing the alignment we need to make sure that the bump position is realigned to the original alignment. That can only be ensured by having a function that takes a closure, like the methods mentioned above do.

pub fn into_aligned<const NEW_MIN_ALIGN: usize>( self, ) -> BumpScope<'a, A, S::WithMinimumAlignment<NEW_MIN_ALIGN>>

where MinimumAlignment<NEW_MIN_ALIGN>: SupportedMinimumAlignment,

Converts this BumpScope into a BumpScope with a new minimum alignment.

This cannot decrease the alignment. Trying to decrease alignment will result in a compile error. You can use aligned or scoped_aligned to decrease the alignment.

When decreasing the alignment we need to make sure that the bump position is realigned to the original alignment. That can only be ensured by having a function that takes a closure, like the methods mentioned above do.

If this was allowed to decrease the alignment it would break minimum alignment:

let mut bump: Bump<Global, 8, true> = Bump::new();
let mut guard = bump.scope_guard();

{
    let scope = guard.scope().into_aligned::<1>();
    scope.alloc(0u8);
}

{
    let scope = guard.scope();
    // scope is not aligned to `MIN_ALIGN`!!
}

pub fn with_settings<NewS>(self) -> BumpScope<'a, A, NewS>

where NewS: BumpAllocatorSettings,

Converts this BumpScope into a BumpScope with new settings.

Not all settings can be converted to. This function will fail to compile if:

• NewS::MIN_ALIGN < S::MIN_ALIGN
• NewS::UP != S::UP
• NewS::GUARANTEED_ALLOCATED > S::GUARANTEED_ALLOCATED
• NewS::CLAIMABLE < S::CLAIMABLE

pub fn borrow_with_settings<NewS>(&self) -> &BumpScope<'a, A, NewS>

where NewS: BumpAllocatorSettings,

Borrows this BumpScope with new settings.

Not all settings can be converted to. This function will fail to compile if:

• NewS::MIN_ALIGN != S::MIN_ALIGN
• NewS::UP != S::UP
• NewS::GUARANTEED_ALLOCATED > S::GUARANTEED_ALLOCATED
• NewS::CLAIMABLE != S::CLAIMABLE

pub fn borrow_mut_with_settings<NewS>(&mut self) -> &mut BumpScope<'a, A, NewS>

where NewS: BumpAllocatorSettings,

Borrows this BumpScope mutably with new settings.

Not all settings can be converted to. This function will fail to compile if:

• NewS::MIN_ALIGN < S::MIN_ALIGN
• NewS::UP != S::UP
• NewS::GUARANTEED_ALLOCATED != S::GUARANTEED_ALLOCATED
• NewS::CLAIMABLE != S::CLAIMABLE

impl<S> BumpScope<'_, Global, S>

where S: BumpAllocatorSettings,

pub fn into_raw(self) -> NonNull<()>

Available on crate feature alloc only.

Converts this BumpScope into a raw pointer.

pub unsafe fn from_raw(ptr: NonNull<()>) -> Self

Available on crate feature alloc only.

Converts the raw pointer that was created with into_raw back into a BumpScope.

Safety

This is highly unsafe, due to the number of invariants that aren’t checked:

• ptr must have been created with Self::into_raw.
• This function must only be called once with this ptr.
• Nothing must have been allocated since then.
• The lifetime must match the original one.
• The settings must match the original ones.

impl<'a, A, S> BumpScope<'a, A, S>

where A: Allocator, S: BumpAllocatorSettings,

Methods that forward to traits.

pub fn claim(&self) -> BumpClaimGuard<'_, 'a, A, S>

Forwards to BumpAllocatorScope::claim.

pub fn is_claimed(&self) -> bool

Forwards to BumpAllocatorCore::is_claimed.

pub fn scope_guard(&mut self) -> BumpScopeGuard<'_, A, S>

Forwards to BumpAllocator::scope_guard.

pub fn scoped<R>(&mut self, f: impl FnOnce(&mut BumpScope<'_, A, S>) -> R) -> R

Forwards to BumpAllocator::scoped.

pub fn scoped_aligned<const NEW_MIN_ALIGN: usize, R>( &mut self, f: impl FnOnce(&mut BumpScope<'_, A, S::WithMinimumAlignment<NEW_MIN_ALIGN>>) -> R, ) -> R

where MinimumAlignment<NEW_MIN_ALIGN>: SupportedMinimumAlignment,

Forwards to BumpAllocator::scoped_aligned.

pub fn aligned<const NEW_MIN_ALIGN: usize, R>( &mut self, f: impl FnOnce(&mut BumpScope<'a, A, S::WithMinimumAlignment<NEW_MIN_ALIGN>>) -> R, ) -> R

where MinimumAlignment<NEW_MIN_ALIGN>: SupportedMinimumAlignment,

Forwards to BumpAllocatorScope::aligned.

pub fn checkpoint(&self) -> Checkpoint

Forwards to BumpAllocatorCore::checkpoint.

pub unsafe fn reset_to(&self, checkpoint: Checkpoint)

Forwards to BumpAllocatorCore::reset_to.

pub fn allocator(&self) -> &A

Forwards to BumpAllocatorScope::allocator.

pub fn alloc<T>(&self, value: T) -> BumpBox<'a, T>

Forwards to BumpAllocatorTypedScope::alloc.

pub fn try_alloc<T>(&self, value: T) -> Result<BumpBox<'a, T>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc.

pub fn alloc_with<T>(&self, f: impl FnOnce() -> T) -> BumpBox<'a, T>

Forwards to BumpAllocatorTypedScope::alloc_with.

pub fn try_alloc_with<T>( &self, f: impl FnOnce() -> T, ) -> Result<BumpBox<'a, T>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_with.

pub fn alloc_default<T: Default>(&self) -> BumpBox<'a, T>

Forwards to BumpAllocatorTypedScope::alloc_default.

pub fn try_alloc_default<T: Default>( &self, ) -> Result<BumpBox<'a, T>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_default.

pub fn alloc_clone<T: CloneToUninit + ?Sized>( &self, value: &T, ) -> BumpBox<'a, T>

Available on crate feature nightly-clone-to-uninit only.

Forwards to BumpAllocatorTypedScope::alloc_clone.

pub fn try_alloc_clone<T: CloneToUninit + ?Sized>( &self, value: &T, ) -> Result<BumpBox<'a, T>, AllocError>

Available on crate feature nightly-clone-to-uninit only.

Forwards to BumpAllocatorTypedScope::try_alloc_clone.

pub fn alloc_slice_move<T>( &self, slice: impl OwnedSlice<Item = T>, ) -> BumpBox<'a, [T]>

Forwards to BumpAllocatorTypedScope::alloc_slice_move.

pub fn try_alloc_slice_move<T>( &self, slice: impl OwnedSlice<Item = T>, ) -> Result<BumpBox<'a, [T]>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_slice_move.

pub fn alloc_slice_copy<T: Copy>(&self, slice: &[T]) -> BumpBox<'a, [T]>

Forwards to BumpAllocatorTypedScope::alloc_slice_copy.

pub fn try_alloc_slice_copy<T: Copy>( &self, slice: &[T], ) -> Result<BumpBox<'a, [T]>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_slice_copy.

pub fn alloc_slice_clone<T: Clone>(&self, slice: &[T]) -> BumpBox<'a, [T]>

Forwards to BumpAllocatorTypedScope::alloc_slice_clone.

pub fn try_alloc_slice_clone<T: Clone>( &self, slice: &[T], ) -> Result<BumpBox<'a, [T]>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_slice_clone.

pub fn alloc_slice_fill<T: Clone>( &self, len: usize, value: T, ) -> BumpBox<'a, [T]>

Forwards to BumpAllocatorTypedScope::alloc_slice_fill.

pub fn try_alloc_slice_fill<T: Clone>( &self, len: usize, value: T, ) -> Result<BumpBox<'a, [T]>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_slice_fill.

pub fn alloc_slice_fill_with<T>( &self, len: usize, f: impl FnMut() -> T, ) -> BumpBox<'a, [T]>

Forwards to BumpAllocatorTypedScope::alloc_slice_fill_with.

pub fn try_alloc_slice_fill_with<T>( &self, len: usize, f: impl FnMut() -> T, ) -> Result<BumpBox<'a, [T]>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_slice_fill_with.

pub fn alloc_str(&self, src: &str) -> BumpBox<'a, str>

Forwards to BumpAllocatorTypedScope::alloc_str.

pub fn try_alloc_str(&self, src: &str) -> Result<BumpBox<'a, str>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_str.

pub fn alloc_fmt(&self, args: Arguments<'_>) -> BumpBox<'a, str>

Forwards to BumpAllocatorTypedScope::alloc_fmt.

pub fn try_alloc_fmt( &self, args: Arguments<'_>, ) -> Result<BumpBox<'a, str>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_fmt.

pub fn alloc_fmt_mut(&mut self, args: Arguments<'_>) -> BumpBox<'a, str>

Forwards to MutBumpAllocatorTypedScope::alloc_fmt_mut.

pub fn try_alloc_fmt_mut( &mut self, args: Arguments<'_>, ) -> Result<BumpBox<'a, str>, AllocError>

Forwards to MutBumpAllocatorTypedScope::try_alloc_fmt_mut.

pub fn alloc_cstr(&self, src: &CStr) -> &'a CStr

Forwards to BumpAllocatorTypedScope::alloc_cstr.

pub fn try_alloc_cstr(&self, src: &CStr) -> Result<&'a CStr, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_cstr.

pub fn alloc_cstr_from_str(&self, src: &str) -> &'a CStr

Forwards to BumpAllocatorTypedScope::alloc_cstr_from_str.

pub fn try_alloc_cstr_from_str(&self, src: &str) -> Result<&'a CStr, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_cstr_from_str.

pub fn alloc_cstr_fmt(&self, args: Arguments<'_>) -> &'a CStr

Forwards to BumpAllocatorTypedScope::alloc_cstr_fmt.

pub fn try_alloc_cstr_fmt( &self, args: Arguments<'_>, ) -> Result<&'a CStr, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_cstr_fmt.

pub fn alloc_cstr_fmt_mut(&mut self, args: Arguments<'_>) -> &'a CStr

Forwards to MutBumpAllocatorTypedScope::alloc_cstr_fmt_mut.

pub fn try_alloc_cstr_fmt_mut( &mut self, args: Arguments<'_>, ) -> Result<&'a CStr, AllocError>

Forwards to MutBumpAllocatorTypedScope::try_alloc_cstr_fmt_mut.

pub fn alloc_iter<T>( &self, iter: impl IntoIterator<Item = T>, ) -> BumpBox<'a, [T]>

Forwards to BumpAllocatorTypedScope::alloc_iter.

pub fn try_alloc_iter<T>( &self, iter: impl IntoIterator<Item = T>, ) -> Result<BumpBox<'a, [T]>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_iter.

pub fn alloc_iter_exact<T, I>( &self, iter: impl IntoIterator<Item = T, IntoIter = I>, ) -> BumpBox<'a, [T]>

where I: ExactSizeIterator<Item = T>,

Forwards to BumpAllocatorTypedScope::alloc_iter_exact.

pub fn try_alloc_iter_exact<T, I>( &self, iter: impl IntoIterator<Item = T, IntoIter = I>, ) -> Result<BumpBox<'a, [T]>, AllocError>

where I: ExactSizeIterator<Item = T>,

Forwards to BumpAllocatorTypedScope::try_alloc_iter_exact.

pub fn alloc_iter_mut<T>( &mut self, iter: impl IntoIterator<Item = T>, ) -> BumpBox<'a, [T]>

Forwards to MutBumpAllocatorTypedScope::alloc_iter_mut.

pub fn try_alloc_iter_mut<T>( &mut self, iter: impl IntoIterator<Item = T>, ) -> Result<BumpBox<'a, [T]>, AllocError>

Forwards to MutBumpAllocatorTypedScope::try_alloc_iter_mut.

pub fn alloc_iter_mut_rev<T>( &mut self, iter: impl IntoIterator<Item = T>, ) -> BumpBox<'a, [T]>

Forwards to MutBumpAllocatorTypedScope::alloc_iter_mut_rev.

pub fn try_alloc_iter_mut_rev<T>( &mut self, iter: impl IntoIterator<Item = T>, ) -> Result<BumpBox<'a, [T]>, AllocError>

Forwards to MutBumpAllocatorTypedScope::try_alloc_iter_mut_rev.

pub fn alloc_uninit<T>(&self) -> BumpBox<'a, MaybeUninit<T>>

Forwards to BumpAllocatorTypedScope::alloc_uninit.

pub fn try_alloc_uninit<T>( &self, ) -> Result<BumpBox<'a, MaybeUninit<T>>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_uninit.

pub fn alloc_uninit_slice<T>(&self, len: usize) -> BumpBox<'a, [MaybeUninit<T>]>

Forwards to BumpAllocatorTypedScope::alloc_uninit_slice.

pub fn try_alloc_uninit_slice<T>( &self, len: usize, ) -> Result<BumpBox<'a, [MaybeUninit<T>]>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_uninit_slice.

pub fn alloc_uninit_slice_for<T>( &self, slice: &[T], ) -> BumpBox<'a, [MaybeUninit<T>]>

Forwards to BumpAllocatorTypedScope::alloc_uninit_slice_for.

pub fn try_alloc_uninit_slice_for<T>( &self, slice: &[T], ) -> Result<BumpBox<'a, [MaybeUninit<T>]>, AllocError>

Forwards to BumpAllocatorTypedScope::try_alloc_uninit_slice_for.

pub fn dealloc<T: ?Sized>(&self, boxed: BumpBox<'_, T>)

Forwards to BumpAllocatorTyped::dealloc.

pub fn reserve(&self, additional: usize)

Forwards to BumpAllocatorTyped::reserve.

pub fn try_reserve(&self, additional: usize) -> Result<(), AllocError>

Forwards to BumpAllocatorTyped::try_reserve.

impl<'a, A, S> BumpScope<'a, A, S>

where A: Allocator, S: BumpAllocatorSettings,

Additional alloc methods that are not available in traits.

pub fn alloc_try_with<T, E>( &self, f: impl FnOnce() -> Result<T, E>, ) -> Result<BumpBox<'a, T>, E>

Allocates the result of f in the bump allocator, then moves E out of it and deallocates the space it took up.

This can be more performant than allocating T after the fact, as Result<T, E> may be constructed in the bump allocators memory instead of on the stack and then copied over.

There is also alloc_try_with_mut, optimized for a mutable reference.

Panics

Panics if the allocation fails.

Examples

let result = bump.alloc_try_with(|| -> Result<i32, i32> { Ok(123) });
assert_eq!(result.unwrap(), 123);
assert_eq!(bump.stats().allocated(), offset_of!(Result<i32, i32>, Ok.0) + size_of::<i32>());

let result = bump.alloc_try_with(|| -> Result<i32, i32> { Err(123) });
assert_eq!(result.unwrap_err(), 123);
assert_eq!(bump.stats().allocated(), 0);

pub fn try_alloc_try_with<T, E>( &self, f: impl FnOnce() -> Result<T, E>, ) -> Result<Result<BumpBox<'a, T>, E>, AllocError>

Allocates the result of f in the bump allocator, then moves E out of it and deallocates the space it took up.

This can be more performant than allocating T after the fact, as Result<T, E> may be constructed in the bump allocators memory instead of on the stack and then copied over.

There is also try_alloc_try_with_mut, optimized for a mutable reference.

Errors

Errors if the allocation fails.

Examples

let result = bump.try_alloc_try_with(|| -> Result<i32, i32> { Ok(123) })?;
assert_eq!(result.unwrap(), 123);
assert_eq!(bump.stats().allocated(), offset_of!(Result<i32, i32>, Ok.0) + size_of::<i32>());

let result = bump.try_alloc_try_with(|| -> Result<i32, i32> { Err(123) })?;
assert_eq!(result.unwrap_err(), 123);
assert_eq!(bump.stats().allocated(), 0);

pub fn alloc_try_with_mut<T, E>( &mut self, f: impl FnOnce() -> Result<T, E>, ) -> Result<BumpBox<'a, T>, E>

Allocates the result of f in the bump allocator, then moves E out of it and deallocates the space it took up.

This can be more performant than allocating T after the fact, as Result<T, E> may be constructed in the bump allocators memory instead of on the stack and then copied over.

This is just like alloc_try_with, but optimized for a mutable reference.

Panics

Panics if the allocation fails.

Examples

let result = bump.alloc_try_with_mut(|| -> Result<i32, i32> { Ok(123) });
assert_eq!(result.unwrap(), 123);
assert_eq!(bump.stats().allocated(), offset_of!(Result<i32, i32>, Ok.0) + size_of::<i32>());

let result = bump.alloc_try_with_mut(|| -> Result<i32, i32> { Err(123) });
assert_eq!(result.unwrap_err(), 123);
assert_eq!(bump.stats().allocated(), 0);

pub fn try_alloc_try_with_mut<T, E>( &mut self, f: impl FnOnce() -> Result<T, E>, ) -> Result<Result<BumpBox<'a, T>, E>, AllocError>

Allocates the result of f in the bump allocator, then moves E out of it and deallocates the space it took up.

This can be more performant than allocating T after the fact, as Result<T, E> may be constructed in the bump allocators memory instead of on the stack and then copied over.

This is just like try_alloc_try_with, but optimized for a mutable reference.

Errors

Errors if the allocation fails.

Examples

let result = bump.try_alloc_try_with_mut(|| -> Result<i32, i32> { Ok(123) })?;
assert_eq!(result.unwrap(), 123);
assert_eq!(bump.stats().allocated(), offset_of!(Result<i32, i32>, Ok.0) + size_of::<i32>());

let result = bump.try_alloc_try_with_mut(|| -> Result<i32, i32> { Err(123) })?;
assert_eq!(result.unwrap_err(), 123);
assert_eq!(bump.stats().allocated(), 0);

Trait Implementations

impl<A, S> Allocator for &mut BumpScope<'_, A, S>

where A: CrateAllocator, S: BumpAllocatorSettings,

Available on crate feature allocator-api2-03 only.

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

Attempts to allocate a block of memory.

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

Deallocates the memory referenced by ptr.

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

Attempts to extend the memory block.

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

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]>, TargetAllocError>

Attempts to shrink the memory block.

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

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

fn by_ref(&self) -> &Self

where Self: Sized,

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

impl<A, S> Allocator for BumpScope<'_, A, S>

where A: Allocator, S: BumpAllocatorSettings,

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

Attempts to allocate a block of memory.

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

Deallocates the memory referenced by ptr.

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

Attempts to extend the memory block.

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

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>

Attempts to shrink the memory block.

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

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

fn by_ref(&self) -> &Self

where Self: Sized,

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

impl<A, S> Allocator for BumpScope<'_, A, S>

where A: CrateAllocator, S: BumpAllocatorSettings,

Available on crate feature nightly-allocator-api only.

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

🔬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]>, TargetAllocError>

🔬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]>, TargetAllocError>

🔬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]>, TargetAllocError>

🔬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, S> Allocator for BumpScope<'_, A, S>

where A: CrateAllocator, S: BumpAllocatorSettings,

Available on crate feature allocator-api2-03 only.

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

Attempts to allocate a block of memory.

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

Deallocates the memory referenced by ptr.

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

Attempts to extend the memory block.

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

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]>, TargetAllocError>

Attempts to shrink the memory block.

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

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

fn by_ref(&self) -> &Self

where Self: Sized,

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

impl<A, S> Allocator for BumpScope<'_, A, S>

where A: CrateAllocator, S: BumpAllocatorSettings,

Available on crate feature allocator-api2-04 only.

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

Attempts to allocate a block of memory.

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

Deallocates the memory referenced by ptr.

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

Attempts to extend the memory block.

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

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]>, TargetAllocError>

Attempts to shrink the memory block.

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

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

fn by_ref(&self) -> &Self

where Self: Sized,

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

impl<A, S> BumpAllocator for BumpScope<'_, A, S>

where A: Allocator, S: BumpAllocatorSettings,

type Allocator = A

The base allocator.

type Settings = S

The bump allocator settings.

fn as_scope(&self) -> &BumpScope<'_, Self::Allocator, Self::Settings>

Returns this bump allocator as a &BumpScope.

fn as_mut_scope( &mut self, ) -> &mut BumpScope<'_, Self::Allocator, Self::Settings>

Returns this bump allocator as a &mut BumpScope.

fn scope_guard(&mut self) -> BumpScopeGuard<'_, Self::Allocator, Self::Settings>

Creates a new BumpScopeGuard.

fn scoped<R>( &mut self, f: impl FnOnce(&mut BumpScope<'_, Self::Allocator, Self::Settings>) -> R, ) -> R

Calls f with a new child scope.

fn scoped_aligned<const NEW_MIN_ALIGN: usize, R>( &mut self, f: impl FnOnce(&mut BumpScope<'_, Self::Allocator, <Self::Settings as BumpAllocatorSettings>::WithMinimumAlignment<NEW_MIN_ALIGN>>) -> R, ) -> R

where MinimumAlignment<NEW_MIN_ALIGN>: SupportedMinimumAlignment,

Calls f with a new child scope of a new minimum alignment.

impl<A, S> BumpAllocatorCore for BumpScope<'_, A, S>

where A: Allocator, S: BumpAllocatorSettings,

fn any_stats(&self) -> AnyStats<'_>

Returns a type which provides statistics about the memory usage of the bump allocator.

fn checkpoint(&self) -> Checkpoint

Creates a checkpoint of the current bump position.

unsafe fn reset_to(&self, checkpoint: Checkpoint)

Resets the bump position to a previously created checkpoint. The memory that has been allocated since then will be reused by future allocations.

fn is_claimed(&self) -> bool

Returns true if the bump allocator is currently claimed.

fn prepare_allocation( &self, layout: Layout, ) -> Result<Range<NonNull<u8>>, AllocError>

Returns a pointer range of free space in the bump allocator with a size of at least layout.size().

unsafe fn allocate_prepared( &self, layout: Layout, range: Range<NonNull<u8>>, ) -> NonNull<u8>

Allocate part of the free space returned from a prepare_allocation call.

fn prepare_allocation_rev( &self, layout: Layout, ) -> Result<Range<NonNull<u8>>, AllocError>

Returns a pointer range of free space in the bump allocator with a size of at least layout.size().

unsafe fn allocate_prepared_rev( &self, layout: Layout, range: Range<NonNull<u8>>, ) -> NonNull<u8>

Allocate part of the free space returned from a prepare_allocation_rev call starting at the end.

impl<'a, A, S> BumpAllocatorScope<'a> for BumpScope<'a, A, S>

where A: Allocator, S: BumpAllocatorSettings,

fn claim(&self) -> BumpClaimGuard<'_, 'a, Self::Allocator, Self::Settings>

Claims exclusive access to the bump allocator from a shared reference.

fn stats(&self) -> Stats<'a, Self::Settings>

Returns a type which provides statistics about the memory usage of the bump allocator.

fn aligned<const NEW_MIN_ALIGN: usize, R>( &mut self, f: impl FnOnce(&mut BumpScope<'a, Self::Allocator, <Self::Settings as BumpAllocatorSettings>::WithMinimumAlignment<NEW_MIN_ALIGN>>) -> R, ) -> R

where MinimumAlignment<NEW_MIN_ALIGN>: SupportedMinimumAlignment,

Calls f with this scope but with a new minimum alignment.

fn allocator(&self) -> &Self::Allocator

Returns a reference to the base allocator.

impl<A, S> BumpAllocatorTyped for BumpScope<'_, A, S>

where A: Allocator, S: BumpAllocatorSettings,

type TypedStats<'b> = Stats<'b, S> where Self: 'b

The type returned by the stats method.

fn typed_stats(&self) -> Self::TypedStats<'_>

Returns a type which provides statistics about the memory usage of the bump allocator.

fn allocate_layout(&self, layout: Layout) -> NonNull<u8>

A specialized version of allocate.

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

A specialized version of allocate.

fn allocate_sized<T>(&self) -> NonNull<T>

A specialized version of allocate.

fn try_allocate_sized<T>(&self) -> Result<NonNull<T>, AllocError>

A specialized version of allocate.

fn allocate_slice<T>(&self, len: usize) -> NonNull<T>

A specialized version of allocate.

fn try_allocate_slice<T>(&self, len: usize) -> Result<NonNull<T>, AllocError>

A specialized version of allocate.

fn allocate_slice_for<T>(&self, slice: &[T]) -> NonNull<T>

A specialized version of allocate.

fn try_allocate_slice_for<T>( &self, slice: &[T], ) -> Result<NonNull<T>, AllocError>

A specialized version of allocate.

unsafe fn shrink_slice<T>( &self, ptr: NonNull<T>, old_len: usize, new_len: usize, ) -> Option<NonNull<T>>

A specialized version of shrink.

fn prepare_slice_allocation<T>(&self, len: usize) -> NonNull<[T]>

A specialized version of prepare_allocation.

fn try_prepare_slice_allocation<T>( &self, len: usize, ) -> Result<NonNull<[T]>, AllocError>

A specialized version of prepare_allocation.

unsafe fn allocate_prepared_slice<T>( &self, start: NonNull<T>, len: usize, cap: usize, ) -> NonNull<[T]>

A specialized version of allocate_prepared.

fn prepare_slice_allocation_rev<T>(&self, len: usize) -> (NonNull<T>, usize)

A specialized version of prepare_allocation_rev.

fn try_prepare_slice_allocation_rev<T>( &self, len: usize, ) -> Result<(NonNull<T>, usize), AllocError>

A specialized version of prepare_allocation_rev.

unsafe fn allocate_prepared_slice_rev<T>( &self, end: NonNull<T>, len: usize, cap: usize, ) -> NonNull<[T]>

A specialized version of allocate_prepared_rev.

fn reserve(&self, additional: usize)

Reserves capacity for at least additional more bytes to be bump allocated. The bump allocator may reserve more space to avoid frequent reallocations. After calling reserve, self.stats().remaining() will be greater than or equal to additional. Does nothing if the capacity is already sufficient.

fn try_reserve(&self, additional: usize) -> Result<(), AllocError>

Reserves capacity for at least additional more bytes to be bump allocated. The bump allocator may reserve more space to avoid frequent reallocations. After calling reserve, self.stats().remaining() will be greater than or equal to additional. Does nothing if the capacity is already sufficient.

fn dealloc<T: ?Sized>(&self, boxed: BumpBox<'_, T>)

Drops an allocated value and attempts to free its memory.

impl<A, S> Debug for BumpScope<'_, A, S>

where S: BumpAllocatorSettings,

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

Formats the value using the given formatter.

impl<'b, A, S> From<&'b Bump<A, S>> for &'b BumpScope<'b, A, S>

where A: Allocator, S: BumpAllocatorSettings,

fn from(value: &'b Bump<A, S>) -> Self

Converts to this type from the input type.

impl<'b, A, S> From<&'b mut Bump<A, S>> for &'b mut BumpScope<'b, A, S>

where A: Allocator, S: BumpAllocatorSettings,

fn from(value: &'b mut Bump<A, S>) -> Self

Converts to this type from the input type.

impl<'a, A, S> BumpAllocatorCoreScope<'a> for BumpScope<'a, A, S>

where A: Allocator, S: BumpAllocatorSettings,

impl<A, S> MutBumpAllocatorCore for BumpScope<'_, A, S>

where A: Allocator, S: BumpAllocatorSettings,

impl<A, S> NoDrop for BumpScope<'_, A, S>

where S: BumpAllocatorSettings,

impl<A, S> RefUnwindSafe for BumpScope<'_, A, S>

where A: RefUnwindSafe, S: BumpAllocatorSettings,

impl<A, S> UnwindSafe for BumpScope<'_, A, S>

where A: RefUnwindSafe, S: BumpAllocatorSettings,