Struct Alloc 

pub struct Alloc<T, A: Allocator> { /* private fields */ }

Allocator-backed memory storage.

Wraps any Allocator to provide a RawMem implementation. Memory is freed and elements are dropped when the Alloc is dropped.

Implementations

impl<T, A: Allocator> Alloc<T, A>

pub const fn new(alloc: A) -> Self

Construct a new empty Alloc<T, A>. It will not allocate until growing.

// It's able to be static
static ALLOC: Global<()> = Global::new();

Trait Implementations

impl<T, A: Allocator + Debug> Debug for Alloc<T, A>

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

Formats the value using the given formatter.

impl<T, A: Allocator> Drop for Alloc<T, A>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, A: Allocator> RawMem for Alloc<T, A>

type Item = T

The element type stored in this memory.

fn allocated(&self) -> &[Self::Item]

Returns a shared slice of all currently initialized elements.

fn allocated_mut(&mut self) -> &mut [Self::Item]

Returns a mutable slice of all currently initialized elements.

unsafe fn grow( &mut self, addition: usize, fill: impl FnOnce(usize, (&mut [T], &mut [MaybeUninit<T>])), ) -> Result<&mut [T]>

Low-level growth: extends the memory by cap elements.

fn shrink(&mut self, cap: usize) -> Result<()>

Removes the last cap elements, dropping them.

fn size_hint(&self) -> Option<usize>

Returns an optional hint about the total capacity, if known.

unsafe fn grow_assumed(&mut self, cap: usize) -> Result<&mut [Self::Item]>

grow which assumes that the memory is already initialized

unsafe fn grow_zeroed(&mut self, cap: usize) -> Result<&mut [Self::Item]>

Safety

unsafe fn grow_zeroed_exact(&mut self, cap: usize) -> Result<&mut [Self::Item]>

Safety

fn grow_with( &mut self, addition: usize, f: impl FnMut() -> Self::Item, ) -> Result<&mut [Self::Item]>

Grows by addition elements, initializing each with the closure f.

unsafe fn grow_with_exact( &mut self, addition: usize, f: impl FnMut() -> Self::Item, ) -> Result<&mut [Self::Item]>

Safety

fn grow_filled( &mut self, cap: usize, value: Self::Item, ) -> Result<&mut [Self::Item]>

where Self::Item: Clone,

Grows by cap elements, each cloned from value.

unsafe fn grow_filled_exact( &mut self, cap: usize, value: Self::Item, ) -> Result<&mut [Self::Item]>

where Self::Item: Clone,

Safety

fn grow_within<R: RangeBounds<usize>>( &mut self, range: R, ) -> Result<&mut [Self::Item]>

where Self::Item: Clone,

Grows by cloning a sub-range of the currently allocated data.

fn grow_from_slice(&mut self, src: &[Self::Item]) -> Result<&mut [Self::Item]>

where Self::Item: Clone,

Grows by cloning all elements from src.