columnation

Trait Region

Source
pub trait Region: Default {
    type Item;

    // Required methods
    unsafe fn copy(&mut self, item: &Self::Item) -> Self::Item;
    fn clear(&mut self);
    fn reserve_items<'a, I>(&mut self, items: I)
       where Self: 'a,
             I: Iterator<Item = &'a Self::Item> + Clone;
    fn reserve_regions<'a, I>(&mut self, regions: I)
       where Self: 'a,
             I: Iterator<Item = &'a Self> + Clone;
    fn heap_size(&self, callback: impl FnMut(usize, usize));

    // Provided methods
    fn with_capacity_items<'a, I>(items: I) -> Self
       where Self: 'a,
             I: Iterator<Item = &'a Self::Item> + Clone { ... }
    fn with_capacity_regions<'a, I>(regions: I) -> Self
       where Self: 'a,
             I: Iterator<Item = &'a Self> + Clone { ... }
}
Expand description

A type that can absorb owned data from type T.

This type will ensure that absorbed data remain valid as long as the instance itself is valid. Responsible users will couple the lifetime of this instance with that of all instances it returns from copy.

Required Associated Types§

Source

type Item

The type of item the region contains.

Required Methods§

Source

unsafe fn copy(&mut self, item: &Self::Item) -> Self::Item

Add a new element to the region.

The argument will be copied in to the region and returned as an owned instance. It is unsafe to unwrap and then drop the result.

§Safety

It is unsafe to use the result in any way other than to reference its contents, and then only for the lifetime of the columnar region. Correct uses of this method are very likely exclusive to this crate.

Source

fn clear(&mut self)

Retain allocations but discard their contents.

The elements in the region do not actually own resources, and their normal Drop implementations will not be called. This method should only be called after all instances returned by copy have been disposed of, as this method may invalidate their contents.

Source

fn reserve_items<'a, I>(&mut self, items: I)
where Self: 'a, I: Iterator<Item = &'a Self::Item> + Clone,

Ensure that the region can absorb items without reallocation.

Source

fn reserve_regions<'a, I>(&mut self, regions: I)
where Self: 'a, I: Iterator<Item = &'a Self> + Clone,

Source

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

Determine this region’s memory used and reserved capacity in bytes.

An implementation should invoke the callback for each distinct allocation, providing the used capacity as the first parameter and the actual capacity as the second parameter. Both parameters represent a number of bytes. The implementation should only mention allocations it owns, but not itself, because another object owns it.

The closure is free to sum the parameters, or do more advanced analysis such as creating a histogram of allocation sizes.

Provided Methods§

Source

fn with_capacity_items<'a, I>(items: I) -> Self
where Self: 'a, I: Iterator<Item = &'a Self::Item> + Clone,

Allocate an instance of Self that can absorb items without reallocation.

Source

fn with_capacity_regions<'a, I>(regions: I) -> Self
where Self: 'a, I: Iterator<Item = &'a Self> + Clone,

Allocate an instance of Self that can absorb the items of regions without reallocation.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§

Source§

impl<T: Copy> Region for CopyRegion<T>

Source§

type Item = T