Struct BumpClaimGuard 

pub struct BumpClaimGuard<'b, 'a, A, S = BumpSettings>
where
    A: BaseAllocator<S::GuaranteedAllocated>,
    S: BumpAllocatorSettings,
{ /* private fields */ }

Returned from BumpAllocatorScope::claim.

Methods from Deref<Target = BumpScope<'a, A, S>>

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.

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

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

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

Returns a reference to the base allocator.

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

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>

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.

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, A, S> Deref for BumpClaimGuard<'_, 'a, A, S>

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

type Target = BumpScope<'a, A, S>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<A, S> DerefMut for BumpClaimGuard<'_, '_, A, S>

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

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<A, S> Drop for BumpClaimGuard<'_, '_, A, S>

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

fn drop(&mut self)

Executes the destructor for this type.