Struct timely::container::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) -> ColumnsRegion<R>

Returns a copy of the value.

fn clone_from(&mut self, source: &ColumnsRegion<R>)

Performs copy-assignment from source.

impl<R> Debug for ColumnsRegion<R>

where R: Debug + Region, <R as Region>::Index: Debug,

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

Formats the value using the given formatter.

impl<R> Default for ColumnsRegion<R>

where R: Region,

fn default() -> ColumnsRegion<R>

Returns the “default value” for a type.

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

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<ColumnsRegion<R>, <__D as Deserializer<'de>>::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 R: for<'a> Region + for<'a> 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 ColumnsRegion<R>: '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 ColumnsRegion<R>> + Clone, ) -> ColumnsRegion<R>

where ColumnsRegion<R>: 'a,

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

fn index( &self, index: <ColumnsRegion<R> as Region>::Index, ) -> <ColumnsRegion<R> as Region>::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 ColumnsRegion<R>: 'a, I: Iterator<Item = &'a ColumnsRegion<R>> + 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>(&self, callback: F)

where F: FnMut(usize, usize),

Heap size, size - capacity

fn reborrow<'b, 'a>( item: <ColumnsRegion<R> as Region>::ReadItem<'a>, ) -> <ColumnsRegion<R> as Region>::ReadItem<'b>

where 'a: 'b, ColumnsRegion<R>: '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 as Region>::Index: Serialize + for<'a> Deserialize<'a>,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.