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: BaseAllocator<S::GuaranteedAllocated>, S: BumpAllocatorSettings,

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

Available on crate feature panic-on-alloc only.

Converts this &mut BumpScope into an owned BumpScope.

Allocates a chunk if none has been allocated yet.

This can be used to remove an indirection, simplify type signatures and allow for more settings conversions via 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>

Converts this &mut BumpScope into an owned BumpScope.

Allocates a chunk if none has been allocated yet.

This can be used to remove an indirection, simplify type signatures and allow for more settings conversions via 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, A, S>

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

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

where NewS: BumpAllocatorSettings,

Converts this BumpScope into a BumpScope with new settings.

This function will fail to compile if:

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

Panics

Panics if !NewS::CLAIMABLE and the bump allocator is currently claimed.

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

where NewS: BumpAllocatorSettings,

Borrows this BumpScope with new settings.

This function will fail to compile if:

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

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

where NewS: BumpAllocatorSettings,

Borrows this BumpScope mutably with new settings.

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: BaseAllocator<S::GuaranteedAllocated>, S: BumpAllocatorSettings,

Methods that forward to traits.

pub fn allocator(&self) -> Option<&'a A>

Forwards to BumpAllocatorScope::allocator.

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 alloc<T>(&self, value: T) -> BumpBox<'a, T>

Available on crate feature panic-on-alloc only.

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>

Available on crate feature panic-on-alloc only.

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>

Available on crate feature panic-on-alloc only.

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 features nightly-clone-to-uninit and panic-on-alloc 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]>

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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>

Available on crate feature panic-on-alloc only.

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>

Available on crate feature panic-on-alloc only.

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>

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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)

Available on crate feature panic-on-alloc only.

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: BaseAllocator<S::GuaranteedAllocated>, 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>

Available on crate feature panic-on-alloc only.

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>

Available on crate feature panic-on-alloc only.

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

where A: BaseAllocator<S::GuaranteedAllocated>, 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: BaseAllocator<S::GuaranteedAllocated>, 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: BaseAllocator<S::GuaranteedAllocated>, 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 &mut BumpScope<'_, A, S>

where A: BaseAllocator<S::GuaranteedAllocated>, 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: BaseAllocator<S::GuaranteedAllocated>, 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: BaseAllocator<S::GuaranteedAllocated>, 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: BaseAllocator<S::GuaranteedAllocated>, 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.

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> BumpAllocatorCoreScope<'a> for BumpScope<'a, A, S>

where A: BaseAllocator<S::GuaranteedAllocated>, S: BumpAllocatorSettings,

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

where A: BaseAllocator<S::GuaranteedAllocated>, 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::Allocator, 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) -> Option<&'a Self::Allocator>

Returns a reference to the base allocator.

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

where A: BaseAllocator<S::GuaranteedAllocated>, S: BumpAllocatorSettings,

type TypedStats<'b> = Stats<'b, A, 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>

Available on crate feature panic-on-alloc only.

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>

Available on crate feature panic-on-alloc only.

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>

Available on crate feature panic-on-alloc only.

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>

Available on crate feature panic-on-alloc only.

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

Available on crate feature panic-on-alloc only.

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)

Available on crate feature panic-on-alloc only.

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)

Available on crate feature panic-on-alloc only.

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: BaseAllocator<S::GuaranteedAllocated>, 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: BaseAllocator<S::GuaranteedAllocated>, S: BumpAllocatorSettings,

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

Converts to this type from the input type.

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

where A: BaseAllocator<S::GuaranteedAllocated>, 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,