Struct Alloc 

pub struct Alloc<T, A>
where
    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> Alloc<T, A>

where A: Allocator,

pub const fn new(alloc: A) -> Alloc<T, A>

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> Debug for Alloc<T, A>

where A: Allocator + Debug,

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

Formats the value using the given formatter.

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

where A: Allocator,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

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

where A: Allocator,

type Item = T

The element type stored in this memory.

fn allocated(&self) -> &[<Alloc<T, A> as RawMem>::Item]

Returns a shared slice of all currently initialized elements.

fn allocated_mut(&mut self) -> &mut [<Alloc<T, A> as RawMem>::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], Error>

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

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

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

grow which assumes that the memory is already initialized

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

Grows by cap elements, zeroing only the uninitialized tail. Elements already initialized by the backend are preserved.

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

Equivalent to grow_zeroed, preserving initialized elements.

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

Grows by addition elements, calling f only for uninitialized elements. Elements already initialized by the backend are preserved.

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

Safety

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

where Self::Item: Clone,

Grows by cap elements, initializing the uninitialized tail from value. Elements already initialized by the backend are preserved.

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

where Self::Item: Clone,

Safety

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

where R: RangeBounds<usize>, 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], Error>

where Self::Item: Clone,

Grows by cloning all elements from src.