Struct LgAllocRegion

pub struct LgAllocRegion<T> {
    local: Region<T>,
    stash: Vec<Region<T>>,
    limit: usize,
}

A region allocator which holds items at stable memory locations.

Items once inserted will not be moved, and their locations in memory can be relied on by others, until the region is cleared.

This type accepts owned data, rather than references, and does not itself intend to implement Region. Rather, it is a useful building block for other less-safe code that wants allocated data to remain at fixed memory locations.

Fields

local: Region<T>

The active allocation into which we are writing.

stash: Vec<Region<T>>

All previously active allocations.

limit: usize

The maximum allocation size

Implementations

impl<T> LgAllocRegion<T>

pub fn with_limit(limit: usize) -> Self

Construct a LgAllocRegion with a allocation size limit.

pub fn clear(&mut self)

Clears the contents without dropping any elements.

pub fn copy_iter<I>(&mut self, items: I) -> &mut [T]

where I: Iterator<Item = T> + ExactSizeIterator,

Copies an iterator of items into the region.

pub fn copy_slice(&mut self, items: &[T]) -> &mut [T]

where T: Clone,

Copies a slice of cloneable items into the region.

pub fn reserve(&mut self, count: usize)

Ensures that there is space in self.local to copy at least count items.

pub fn with_capacity(count: usize) -> Self

Allocates a new Self that can accept count items without reallocation.

pub fn len(&self) -> usize

The number of items current held in the region.

pub fn heap_size(&self, callback: impl FnMut(usize, usize))

Visit contained allocations to determine their size and capacity.

Trait Implementations

impl<T> Debug for LgAllocRegion<T>

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

Formats the value using the given formatter.

impl<T> Default for LgAllocRegion<T>

fn default() -> Self

Returns the “default value” for a type.