Struct flatcontainer::impls::columns::ColumnsRegion

pub struct ColumnsRegion<R>
where
    R: Region,
{ /* private fields */ }

A region that can store a variable number of elements per row.

The region is backed by a number of columns, where the number depends on the length of the longest row encountered. For pushed row, the region remembers the indices into each column that populated. Rows can have different lengths, which means that only the first columns will contain a value.

All columns have the same type R.

Examples

Copy a table-like structure:

let data = [
    vec![],
    vec!["1"],
    vec!["2", "3"],
    vec!["4", "5", "6"],
    vec!["7", "8"],
    vec!["9"],
    vec![],
];

let mut r = <ColumnsRegion<ConsecutiveOffsetPairs<StringRegion>>>::default();

let mut indices = Vec::with_capacity(data.len());

for row in &data {
    let index = r.push(row);
    indices.push(index);
}

for (&index, row) in indices.iter().zip(&data) {
    assert!(row.iter().copied().eq(r.index(index).iter()));
}

Trait Implementations

impl<R> Clone for ColumnsRegion<R>

where R: Region + Clone,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R> Debug for ColumnsRegion<R>

where R: Region + Debug, R::Index: Debug,

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

Formats the value using the given formatter.

impl<R> Default for ColumnsRegion<R>

where R: Region,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, R> Deserialize<'de> for ColumnsRegion<R>

where R: Region + Serialize + for<'a> Deserialize<'a>, R::Index: Serialize + for<'a> Deserialize<'a>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, R, T> Push<&'a [T]> for ColumnsRegion<R>

where R: Region + Push<&'a T>,

fn push(&mut self, item: &'a [T]) -> <ColumnsRegion<R> as Region>::Index

Push item into self, returning an index that allows to look up the corresponding read item.

impl<'a, R, T, const N: usize> Push<&'a [T; N]> for ColumnsRegion<R>

where R: Region + Push<&'a T>,

fn push(&mut self, item: &'a [T; N]) -> <ColumnsRegion<R> as Region>::Index

Push item into self, returning an index that allows to look up the corresponding read item.

impl<'a, R, T> Push<&'a Vec<T>> for ColumnsRegion<R>

where R: Region + Push<&'a T>,

fn push(&mut self, item: &'a Vec<T>) -> <ColumnsRegion<R> as Region>::Index

Push item into self, returning an index that allows to look up the corresponding read item.

impl<R, T, const N: usize> Push<[T; N]> for ColumnsRegion<R>

where R: Region + Push<T>,

fn push(&mut self, item: [T; N]) -> <ColumnsRegion<R> as Region>::Index

Push item into self, returning an index that allows to look up the corresponding read item.

impl<R, T, I> Push<CopyIter<I>> for ColumnsRegion<R>

where R: Region + Push<T>, I: IntoIterator<Item = T>,

fn push(&mut self, item: CopyIter<I>) -> <ColumnsRegion<R> as Region>::Index

Push item into self, returning an index that allows to look up the corresponding read item.

impl<R> Push<ReadColumns<'_, R>> for ColumnsRegion<R>

where for<'a> R: Region + Push<<R as Region>::ReadItem<'a>>,

fn push( &mut self, item: ReadColumns<'_, R>, ) -> <ColumnsRegion<R> as Region>::Index

Push item into self, returning an index that allows to look up the corresponding read item.

impl<R, T> Push<Vec<T>> for ColumnsRegion<R>

where R: Region + Push<T>,

fn push(&mut self, item: Vec<T>) -> <ColumnsRegion<R> as Region>::Index

Push item into self, returning an index that allows to look up the corresponding read item.

impl<R> Region for ColumnsRegion<R>

where R: Region,

type Owned = Vec<<R as Region>::Owned>

An owned type that can be constructed from a read item.

type ReadItem<'a> = ReadColumns<'a, R> where Self: 'a

The type of the data that one gets out of the container.

type Index = usize

The type to index into the container. Should be treated as an opaque type, even if known.

fn merge_regions<'a>(regions: impl Iterator<Item = &'a Self> + Clone) -> Self

where Self: 'a,

Construct a region that can absorb the contents of regions in the future.

fn index(&self, index: Self::Index) -> Self::ReadItem<'_>

Index into the container. The index must be obtained by pushing data into the container.

fn reserve_regions<'a, I>(&mut self, regions: I)

where Self: 'a, I: Iterator<Item = &'a Self> + Clone,

Ensure that the region can absorb the items of regions without reallocation

fn clear(&mut self)

Remove all elements from this region, but retain allocations if possible.

fn heap_size<F: FnMut(usize, usize)>(&self, callback: F)

Heap size, size - capacity

fn reborrow<'b, 'a: 'b>(item: Self::ReadItem<'a>) -> Self::ReadItem<'b>

where Self: 'a,

Converts a read item into one with a narrower lifetime.

impl<R> Serialize for ColumnsRegion<R>

where R: Region + Serialize + for<'a> Deserialize<'a>, R::Index: Serialize + for<'a> Deserialize<'a>,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.