A no_std bump allocator sourcing space from a user-provided mutable
slice rather than from a global allocator, making it suitable for use
in embedded applications and tight loops.
Values held in BumpInto allocations are never dropped. If they must
be dropped, you can use core::mem::ManuallyDrop::drop or
core::ptr::drop_in_place to drop them explicitly (and unsafely).
In safe code, you can allocate an Option and drop the value inside
by overwriting it with None.
```rust use bump_into::{self, BumpInto};
// allocate 64 bytes of uninitialized space on the stack let mut bumpintospace = bumpinto::spaceuninit!(64); let bumpinto = BumpInto::fromslice(&mut bumpintospace[..]);
// allocating an object produces a mutable reference with
// a lifetime borrowed from bump_into_space, or gives
// back its argument in Err if there isn't enough space
let number: &mut u64 = bumpinto
.allocwith(|| 123)
.ok()
.expect("not enough space");
asserteq!(*number, 123);
*number = 50000;
asserteq!(*number, 50000);
// slices can be allocated as well let slice: &mut [u16] = bumpinto .allocnwith(5, core::iter::repeat(10)) .expect("not enough space"); asserteq!(slice, &[10; 5]); slice[2] = 100; assert_eq!(slice, &[10, 10, 100, 10, 10]); ```
Copyright (c) 2020 autumnontape
This project may be reproduced under the terms of the MIT license, a copy of which should be available to you in a file called COPYING.