Struct flatk::chunked::Chunked

pub struct Chunked<S, O = Offsets> {
    pub chunks: O,
    pub data: S,
}

A partitioning of the collection S into distinct chunks.

Fields

chunks: O

This can be either offsets of a uniform chunk size, if chunk size is specified at compile time.

data: S

Methods

impl<S, O> Chunked<S, O>

pub fn data(&self) -> &S

Get a immutable reference to the underlying data.

Example

use flatk::*;
let v = vec![1,2,3,4,5,6];
let s = Chunked::from_offsets(vec![0,3,4,6], v.clone());
assert_eq!(&v, s.data());

pub fn data_mut(&mut self) -> &mut S

Get a mutable reference to the underlying data.

Example

use flatk::*;
let mut v = vec![1,2,3,4,5,6];
let mut s = Chunked::from_offsets(vec![0,3,4,6], v.clone());
v[2] = 100;
s.data_mut()[2] = 100;
assert_eq!(&v, s.data());

impl<S: Set> Chunked<S>

pub fn from_sizes<L>(sizes: L, data: S) -> Self where
    L: AsRef<[usize]>, 

Construct a Chunked collection of elements from a set of sizes that determine the number of elements in each chunk. The sum of the sizes must not be greater than the given collection data.

Panics

This function will panic if the sum of all given sizes is greater than data.len().

Example

use flatk::*;
let s = Chunked::from_sizes(vec![3,1,2], vec![1,2,3,4,5,6]);
let mut iter = s.iter();
assert_eq!(vec![1,2,3], iter.next().unwrap().to_vec());
assert_eq!(vec![4], iter.next().unwrap().to_vec());
assert_eq!(vec![5,6], iter.next().unwrap().to_vec());
assert_eq!(None, iter.next());

impl<S: Set, O: AsRef<[usize]>> Chunked<S, Offsets<O>>

pub fn from_offsets(offsets: O, data: S) -> Self

Construct a Chunked collection of elements given a collection of offsets into S. This is the most efficient constructor for creating variable sized chunks, however it is also the most error prone.

Panics

The absolute value of offsets is not significant, however their relative quantities are. More specifically, if x is the first offset, then the last element of offsets must always be data.len() + x. This also implies that offsets cannot be empty. This function panics if any one of these invariants isn't satisfied.

Example

use flatk::*;
let s = Chunked::from_offsets(vec![0,3,4,6], vec![1,2,3,4,5,6]);
let mut iter = s.iter();
assert_eq!(vec![1,2,3], iter.next().unwrap().to_vec());
assert_eq!(vec![4], iter.next().unwrap().to_vec());
assert_eq!(vec![5,6], iter.next().unwrap().to_vec());
assert_eq!(None, iter.next());

impl<'a, S, T, I, O> Chunked<Sparse<S, T, I>, Offsets<O>> where
    I: Dummy + AsMut<[usize]>,
    T: Dummy + Set + View<'a>,
    <T as View<'a>>::Type: Set + Clone + Dummy,
    S: Dummy + Set + ViewMut<'a>,
    <S as ViewMut<'a>>::Type: Set + SplitAt + Dummy + PermuteInPlace,
    O: Clone + AsRef<[usize]>, 

pub fn sort_chunks_by_index(&'a mut self)

Sort each sparse chunk by the source index.

Example

use flatk::*;
let sparse = Sparse::from_dim(vec![0,2,1,2,0], 4, vec![1,2,3,4,5]);
let mut chunked = Chunked::from_sizes(vec![3,2], sparse);
chunked.sort_chunks_by_index();
assert_eq!(chunked.storage(), &[1,3,2,5,4]);
assert_eq!(chunked.data().indices(), &[0,1,2,0,2]);

impl<'a, S, T, I, O> Chunked<Sparse<S, T, I>, Offsets<O>> where
    S: Storage + IntoOwned + Set + View<'a>,
    S::Storage: Set,
    <S as View<'a>>::Type: SplitAt + Dummy + Set,
    T: View<'a> + Set + Clone,
    <T as View<'a>>::Type: Set + Dummy + Clone,
    I: AsRef<[usize]>,
    O: Set + AsRef<[usize]>, 

pub fn compressed<E>(
    &'a self,
    combine: impl FnMut(&mut E::Owned, E)
) -> Chunked<Sparse<S::Owned, T>, Offsets> where
    <S as View<'a>>::Type: IntoIterator<Item = E>,
    E: IntoOwned,
    S::Owned: Set<Elem = E::Owned> + Default + Reserve + Push<E::Owned>, 

Combine elements in each sorted chunk with the same index using the given function.

Assuming that the chunks are sorted by index, this function will combine adjacent elements with the same index into one element.

Example

use flatk::*;
let sparse = Sparse::from_dim(vec![0,2,1,1,2,0,2], 4, vec![1,2,3,4,5,6,7]);
let mut chunked = Chunked::from_sizes(vec![4,3], sparse);
chunked.sort_chunks_by_index();
let compressed = chunked.compressed(|a, b| *a += *b);
assert_eq!(compressed.view().offsets().into_inner(), &[0,3,5]);
assert_eq!(compressed.view().storage(), &[1,7,2,6,12]);
assert_eq!(compressed.view().data().indices(), &[0,1,2,0,2]);

impl<'a, S, T, I, O> Chunked<Sparse<S, T, I>, Offsets<O>> where
    S: Storage + IntoOwned + Set + View<'a>,
    S::Storage: Set,
    <S as View<'a>>::Type: SplitAt + Dummy + Set,
    T: View<'a> + Set + Clone,
    <T as View<'a>>::Type: Set + Dummy + Clone,
    I: AsRef<[usize]>,
    O: Set + AsRef<[usize]>, 

pub fn pruned<E>(
    &'a self,
    combine: impl FnMut(&mut E::Owned, E),
    keep: impl FnMut(usize, usize, &E::Owned) -> bool
) -> Chunked<Sparse<S::Owned, T>, Offsets> where
    <S as View<'a>>::Type: IntoIterator<Item = E>,
    E: IntoOwned,
    S::Owned: Set<Elem = E::Owned> + Default + Reserve + Push<E::Owned>, 

impl<S: Set, O> Chunked<S, O>

pub fn into_inner(self) -> (O, S)

Convert this Chunked into its inner representation, which consists of a collection of offsets (first output) along with the underlying data storage type (second output).

Example

use flatk::*;
let data = vec![1,2,3,4,5,6];
let offsets = vec![0,3,4,6];
let s = Chunked::from_offsets(offsets.clone(), data.clone());
assert_eq!(s.into_inner(), (chunked::Offsets::new(offsets), data));

pub fn as_inner_mut(&mut self) -> (&mut O, &mut S)

This function mutably borrows the inner structure of the chunked collection.

impl<S, O> Chunked<S, O> where
    O: AsRef<[usize]>, 

pub fn offset(&self, index: usize) -> usize

Return the offset into data of the element at the given index. This function returns the total length of data if index is equal to self.len().

Panics

This function panics if index is larger than self.len().

Example

use flatk::*;
let s = Chunked::from_offsets(vec![2,5,6,8], vec![1,2,3,4,5,6]);
assert_eq!(0, s.offset(0));
assert_eq!(3, s.offset(1));
assert_eq!(4, s.offset(2));

pub fn offset_value(&self, index: usize) -> usize

Return the raw offset value of the element at the given index.

Panics

This function panics if index is larger than self.len().

Example

use flatk::*;
let s = Chunked::from_offsets(vec![2,5,6,8], vec![1,2,3,4,5,6]);
assert_eq!(2, s.offset_value(0));
assert_eq!(5, s.offset_value(1));
assert_eq!(6, s.offset_value(2));

pub fn offsets(&self) -> &O

pub fn chunk_len(&self, chunk_index: usize) -> usize

Get the length of the chunk at the given index. This is equivalent to self.get(chunk_index).len().

impl<S, O> Chunked<S, Offsets<O>> where
    O: AsRef<[usize]> + AsMut<[usize]>, 

pub fn transfer_forward(&mut self, chunk_index: usize, num_elements: usize)

Move a number of elements from a chunk at the given index to the following chunk. If the last chunk is selected, then the transferred elements are effectively removed.

This operation is efficient and only performs one write on a single element in an array of usize.

Example

use flatk::*;
let v = vec![1,2,3,4,5];
let mut c = Chunked::from_sizes(vec![3,2], v);
let mut c_iter = c.iter();
assert_eq!(Some(&[1,2,3][..]), c_iter.next());
assert_eq!(Some(&[4,5][..]), c_iter.next());
assert_eq!(None, c_iter.next());

// Transfer 2 elements from the first chunk to the next.
c.transfer_forward(0, 2);
let mut c_iter = c.iter();
assert_eq!(Some(&[1][..]), c_iter.next());
assert_eq!(Some(&[2,3,4,5][..]), c_iter.next());
assert_eq!(None, c_iter.next());

pub fn transfer_forward_all_but(
    &mut self,
    chunk_index: usize,
    num_elements_to_keep: usize
)

Like transfer_forward but specify the number of elements to keep instead of the number of elements to transfer in the chunk at chunk_index.

impl<S, O> Chunked<S, Offsets<O>> where
    O: AsRef<[usize]> + AsMut<[usize]>,
    S: RemovePrefix, 

pub fn transfer_backward(&mut self, chunk_index: usize, num_elements: usize)

Move a number of elements from a chunk at the given index to the previous chunk. If the first chunk is selected, then the transferred elements are explicitly removed, which may cause reallocation if the underlying storage type manages memory.

This operation is efficient and only performs one write on a single element in an array of usize, unless a reallocation is triggered.

Example

use flatk::*;
let v = vec![1,2,3,4,5];
let mut c = Chunked::from_sizes(vec![3,2], v);
let mut c_iter = c.iter();
assert_eq!(Some(&[1,2,3][..]), c_iter.next());
assert_eq!(Some(&[4,5][..]), c_iter.next());
assert_eq!(None, c_iter.next());

// Transfer 2 elements from the first chunk to the next.
c.transfer_backward(1, 1);
let mut c_iter = c.iter();
assert_eq!(Some(&[1,2,3,4][..]), c_iter.next());
assert_eq!(Some(&[5][..]), c_iter.next());
assert_eq!(None, c_iter.next());

impl<S: Default, O: Default> Chunked<S, O>

pub fn new() -> Self

Construct an empty Chunked type.

impl<S> Chunked<S> where
    S: Set + Default + ExtendFromSlice<Item = <S as Set>::Elem>, 

pub fn from_nested_vec(nested_data: Vec<Vec<<S as Set>::Elem>>) -> Self

Construct a Chunked Vec from a nested Vec.

Example

use flatk::*;
let s = Chunked::<Vec<_>>::from_nested_vec(vec![vec![1,2,3],vec![4],vec![5,6]]);
let mut iter = s.iter();
assert_eq!(vec![1,2,3], iter.next().unwrap().to_vec());
assert_eq!(vec![4], iter.next().unwrap().to_vec());
assert_eq!(vec![5,6], iter.next().unwrap().to_vec());
assert_eq!(None, iter.next());

impl<S, O> Chunked<S, O> where
    S: Truncate + Set,
    O: AsRef<[usize]>, 

pub fn trim_data(&mut self) -> usize

Remove any unused data past the last offset. Return the number of elements removed.

Example

use flatk::*;
let mut s = Chunked::from_sizes(vec![1,3,2], vec![1,2,3,4,5,6]);
assert_eq!(3, s.len());

// Transferring the last two elements past the indexed stack.
// This creates a zero sized chunk at the end.
s.transfer_forward(2, 2);
assert_eq!(6, s.data().len());
assert_eq!(3, s.len());

s.trim_data(); // Remove unindexed elements.
assert_eq!(4, s.data().len());

impl<S, O> Chunked<S, O> where
    S: Truncate + Set,
    O: AsRef<[usize]> + Truncate, 

pub fn trim(&mut self) -> usize

Remove any empty chunks at the end of the collection and any unindexed data past the last offset. Return the number of chunks removed.

Example

use flatk::*;
let mut s = Chunked::from_sizes(vec![1,3,2], vec![1,2,3,4,5,6]);
assert_eq!(3, s.len());

// Transferring the last two elements past the indexed stack.
// This creates an empty chunk at the end.
s.transfer_forward(2, 2);
assert_eq!(6, s.data().len());
assert_eq!(3, s.len());

s.trim(); // Remove unindexed elements.
assert_eq!(4, s.data().len());

impl<S, O> Chunked<S, O> where
    S: Set + ExtendFromSlice<Item = <S as Set>::Elem>,
    O: Push<usize>, 

pub fn push_slice(&mut self, element: &[<S as Set>::Elem])

Push a slice of elements onto this Chunked. This can be more efficient than pushing from an iterator.

Example

use flatk::*;
let mut s = Chunked::from_offsets(vec![0,3,5], vec![1,2,3,4,5]);
assert_eq!(2, s.len());
s.push_slice(&[1,2]);
assert_eq!(3, s.len());

impl<S, O> Chunked<S, O> where
    S: Set,
    O: Push<usize>, 

pub fn push_iter<I: IntoIterator>(&mut self, iter: I) where
    S: Extend<I::Item>, 

Push a chunk using an iterator over chunk elements.

Example

use flatk::*;
let mut s = Chunked::from_offsets(vec![0,3,5], vec![1,2,3,4,5]);
assert_eq!(2, s.len());
s.push_iter(std::iter::repeat(100).take(4));
assert_eq!(3, s.len());
assert_eq!(&[100; 4][..], s.view().at(2));

impl<S, O> Chunked<S, Offsets<O>> where
    S: Set + Extend<<S as Set>::Elem>,
    O: AsMut<[usize]>, 

pub fn extend_last<I: IntoIterator<Item = <S as Set>::Elem>>(&mut self, iter: I)

Extend the last chunk with the given iterator.

Example

use flatk::*;
let mut s = Chunked::from_offsets(vec![0,3,5], vec![1,2,3,4,5]);
assert_eq!(2, s.len());
s.extend_last(std::iter::repeat(100).take(2));
assert_eq!(2, s.len());
assert_eq!(&[4, 5, 100, 100][..], s.view().at(1));

impl<'a, S, O> Chunked<S, O> where
    S: View<'a>,
    O: View<'a, Type = Offsets<&'a [usize]>>, 

Important traits for VarIter<'a, V>

impl<'a, V> Iterator for VarIter<'a, V> where
    V: SplitAt + Set + Dummy,  type Item = V;

pub fn iter(&'a self) -> VarIter<'a, <S as View<'a>>::Type>

Produce an iterator over elements (borrowed slices) of a Chunked.

Examples

The following simple example demonstrates how to iterate over a Chunked of integers stored in a flat Vec.

use flatk::*;
let s = Chunked::from_offsets(vec![0,3,4,6], vec![1,2,3,4,5,6]);
let mut iter = s.iter();
let mut e0_iter = iter.next().unwrap().iter();
assert_eq!(Some(&1), e0_iter.next());
assert_eq!(Some(&2), e0_iter.next());
assert_eq!(Some(&3), e0_iter.next());
assert_eq!(None, e0_iter.next());
assert_eq!(Some(&[4][..]), iter.next());
assert_eq!(Some(&[5,6][..]), iter.next());
assert_eq!(None, iter.next());

Nested Chunkeds can also be used to create more complex data organization:

use flatk::*;
let s0 = Chunked::from_offsets(vec![0,3,4,6,9,11], vec![1,2,3,4,5,6,7,8,9,10,11]);
let s1 = Chunked::from_offsets(vec![0,1,4,5], s0);
let mut iter1 = s1.iter();
let v0 = iter1.next().unwrap();
let mut iter0 = v0.iter();
assert_eq!(Some(&[1,2,3][..]), iter0.next());
assert_eq!(None, iter0.next());
let v0 = iter1.next().unwrap();
let mut iter0 = v0.iter();
assert_eq!(Some(&[4][..]), iter0.next());
assert_eq!(Some(&[5,6][..]), iter0.next());
assert_eq!(Some(&[7,8,9][..]), iter0.next());
assert_eq!(None, iter0.next());
let v0 = iter1.next().unwrap();
let mut iter0 = v0.iter();
assert_eq!(Some(&[10,11][..]), iter0.next());
assert_eq!(None, iter0.next());

impl<'a, S, O> Chunked<S, O> where
    S: ViewMut<'a>,
    O: View<'a, Type = Offsets<&'a [usize]>>, 

Important traits for VarIter<'a, V>

impl<'a, V> Iterator for VarIter<'a, V> where
    V: SplitAt + Set + Dummy,  type Item = V;

pub fn iter_mut(&'a mut self) -> VarIter<'a, <S as ViewMut<'a>>::Type>

Produce a mutable iterator over elements (borrowed slices) of a Chunked.

Example

use flatk::*;
let mut s = Chunked::from_offsets(vec![0,3,4,6], vec![1,2,3,4,5,6]);
for i in s.view_mut().iter_mut() {
    for j in i.iter_mut() {
        *j += 1;
    }
}
let mut iter = s.iter();
assert_eq!(vec![2,3,4], iter.next().unwrap().to_vec());
assert_eq!(vec![5], iter.next().unwrap().to_vec());
assert_eq!(vec![6,7], iter.next().unwrap().to_vec());
assert_eq!(None, iter.next());

Nested Chunkeds can also be used to create more complex data organization:

use flatk::*;
let mut s0 = Chunked::from_offsets(vec![0,3,4,6,9,11], vec![0,1,2,3,4,5,6,7,8,9,10]);
let mut s1 = Chunked::from_offsets(vec![0,1,4,5], s0);
for mut v0 in s1.view_mut().iter_mut() {
    for i in v0.iter_mut() {
        for j in i.iter_mut() {
            *j += 1;
        }
    }
}
let v1 = s1.view();
let mut iter1 = v1.iter();
let v0 = iter1.next().unwrap();
let mut iter0 = v0.iter();
assert_eq!(Some(&[1,2,3][..]), iter0.next());
assert_eq!(None, iter0.next());
let v0 = iter1.next().unwrap();
let mut iter0 = v0.iter();
assert_eq!(Some(&[4][..]), iter0.next());
assert_eq!(Some(&[5,6][..]), iter0.next());
assert_eq!(Some(&[7,8,9][..]), iter0.next());
assert_eq!(None, iter0.next());
let v0 = iter1.next().unwrap();
let mut iter0 = v0.iter();
assert_eq!(Some(&[10,11][..]), iter0.next());
assert_eq!(None, iter0.next());

Trait Implementations

impl<'a, S, O> AtomIterator<'a> for Chunked<S, O> where
    S: AtomIterator<'a>, 

type Item = S::Item

type Iter = S::Iter

fn atom_iter(&'a self) -> Self::Iter

impl<'a, S, O> AtomMutIterator<'a> for Chunked<S, O> where
    S: AtomMutIterator<'a>, 

type Item = S::Item

type Iter = S::Iter

fn atom_mut_iter(&'a mut self) -> Self::Iter

impl<S: Clear> Clear for Chunked<S>

fn clear(&mut self)

Remove all elements from the current set without necessarily deallocating the space previously used.

impl<S: Clone, O: Clone> Clone for Chunked<S, O>

fn clone(&self) -> Chunked<S, O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, S: CloneWithStorage<T>, O: Clone> CloneWithStorage<T> for Chunked<S, O>

type CloneType = Chunked<S::CloneType, O>

fn clone_with_storage(&self, storage: T) -> Self::CloneType

impl<S: Copy, O: Copy> Copy for Chunked<S, O>

impl<S: Debug, O: Debug> Debug for Chunked<S, O>

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

Formats the value using the given formatter.

impl<S: Default, O: Default> Default for Chunked<S, O>

fn default() -> Self

Construct an empty Chunked.

impl<S: Dummy, O: Dummy> Dummy for Chunked<S, O>

unsafe fn dummy() -> Self

impl<'a, S, O> FromIterator<&'a [<S as Set>::Elem]> for Chunked<S, O> where
    S: Set + ExtendFromSlice<Item = <S as Set>::Elem> + Default,
    <S as Set>::Elem: 'a,
    O: Default + Push<usize>, 

fn from_iter<T>(iter: T) -> Self where
    T: IntoIterator<Item = &'a [<S as Set>::Elem]>, 

Construct a Chunked collection from an iterator over immutable slices.

Example

use flatk::*;
let v = [&[1,2,3][..], &[4][..], &[5,6][..]];
let s: Chunked::<Vec<_>> = v.iter().cloned().collect();
let mut iter = s.iter();
assert_eq!(Some(&[1,2,3][..]), iter.next());
assert_eq!(Some(&[4][..]), iter.next());
assert_eq!(Some(&[5,6][..]), iter.next());
assert_eq!(None, iter.next());

impl<S> FromIterator<Vec<<S as Set>::Elem>> for Chunked<S> where
    S: Set + Default + ExtendFromSlice<Item = <S as Set>::Elem>, 

fn from_iter<T>(iter: T) -> Self where
    T: IntoIterator<Item = Vec<<S as Set>::Elem>>, 

Construct a Chunked from an iterator over Vec types.

Example

use flatk::*;
use std::iter::FromIterator;
let s = Chunked::<Vec<_>>::from_iter(vec![vec![1,2,3],vec![4],vec![5,6]].into_iter());
let mut iter = s.iter();
assert_eq!(vec![1,2,3], iter.next().unwrap().to_vec());
assert_eq!(vec![4], iter.next().unwrap().to_vec());
assert_eq!(vec![5,6], iter.next().unwrap().to_vec());
assert_eq!(None, iter.next());

impl<'a, S, O> GetIndex<'a, Chunked<S, O>> for usize where
    S: Set + View<'a> + Get<'a, Range<usize>, Output = <S as View<'a>>::Type>,
    O: IndexRange, 

type Output = S::Output

fn get(self, chunked: &Chunked<S, O>) -> Option<Self::Output>

Get an element of the given Chunked collection.

Example

use flatk::*;
let v = vec![0, 1, 4, 6];
let data = (1..=6).collect::<Vec<_>>();
let s = Chunked::from_offsets(v.as_slice(), data.view());
assert_eq!(Some(&[1][..]), s.get(0));
assert_eq!(Some(&[2,3,4][..]), s.get(1));
assert_eq!(Some(&[5,6][..]), s.get(2));

impl<'a, S, O> GetIndex<'a, Chunked<S, O>> for Range<usize> where
    S: Set + View<'a> + Get<'a, Range<usize>, Output = <S as View<'a>>::Type>,
    O: IndexRange + Get<'a, Range<usize>>, 

type Output = Chunked<S::Output, O::Output>

fn get(self, chunked: &Chunked<S, O>) -> Option<Self::Output>

Get a [begin..end) subview of the given Chunked collection.

Example

use flatk::*;
let data = (1..=6).collect::<Vec<_>>();
let offsets = vec![1, 2, 5, 7]; // Offsets don't have to start at 0
let s = Chunked::from_offsets(offsets.as_slice(), data.view());
let v = s.get(1..3).unwrap();
assert_eq!(Some(&[2,3,4][..]), v.get(0));
assert_eq!(Some(&[5,6][..]), v.get(1));

impl<T, O> Index<usize> for Chunked<Vec<T>, O> where
    O: Index<usize, Output = usize>, 

type Output = <[T] as Index<Range<usize>>>::Output

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Get reference to a chunk at the given index. Note that this works for Chunked collections that are themselves NOT Chunked, since a chunk of a doubly Chunked collection is itself Chunked, which cannot be represented by a single borrow. For more complex indexing use the get method provided by the Get trait.

Example

use flatk::*;
let v = vec![1,2,3,4,5,6,7,8,9,10,11];
let s = Chunked::from_offsets(vec![0,3,4,6,9,11], v.clone());
assert_eq!(2, (&s[2]).len());
assert_eq!(&[5,6], &s[2]);

impl<'_, T, O> Index<usize> for Chunked<&'_ [T], O> where
    O: AsRef<[usize]>, 

type Output = [T]

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Immutably index the Chunked borrowed slice by usize. Note that this works for chunked collections that are themselves not chunked, since the item at the index of a doubly chunked collection is itself chunked, which cannot be represented by a single borrow. For more complex indexing use the get method provided by the Get trait.

Example

use flatk::*;
let v = vec![1,2,3,4,5,6,7,8,9,10,11];
let s = Chunked::from_offsets(vec![0,3,4,6,9,11], v.as_slice());
assert_eq!(&[5,6], &s[2]);

impl<'_, T, O> Index<usize> for Chunked<&'_ mut [T], O> where
    O: Index<usize, Output = usize>, 

type Output = <[T] as Index<Range<usize>>>::Output

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Immutably index the Chunked mutably borrowed slice by usize. Note that this works for chunked collections that are themselves not chunked, since the item at the index of a doubly chunked collection is itself chunked, which cannot be represented by a single borrow. For more complex indexing use the get method provided by the Get trait.

Example

use flatk::*;
let mut v = vec![1,2,3,4,5,6,7,8,9,10,11];
let s = Chunked::from_offsets(vec![0,3,4,6,9,11], v.as_mut_slice());
assert_eq!(&[5,6], &s[2]);

impl<T, O> IndexMut<usize> for Chunked<Vec<T>, O> where
    O: Index<usize, Output = usize>, 

fn index_mut(&mut self, idx: usize) -> &mut Self::Output

Mutably index the Chunked Vec by usize. Note that this works for chunked collections that are themselves not chunked, since the item at the index of a doubly chunked collection is itself chunked, which cannot be represented by a single borrow. For more complex indexing use the get method provided by the Get trait.

Example

use flatk::*;
let mut v = vec![1,2,3,4,0,0,7,8,9,10,11];
let mut s = Chunked::from_offsets(vec![0,3,4,6,9,11], v.clone());
s[2].copy_from_slice(&[5,6]);
assert_eq!(vec![1,2,3,4,5,6,7,8,9,10,11], s.into_flat());

impl<'_, T, O> IndexMut<usize> for Chunked<&'_ mut [T], O> where
    O: Index<usize, Output = usize>, 

fn index_mut(&mut self, idx: usize) -> &mut Self::Output

Mutably index the Chunked mutably borrowed slice by usize. Note that this works for chunked collections that are themselves not chunked, since the item at the index of a doubly chunked collection is itself chunked, which cannot be represented by a single borrow. For more complex indexing use the get method provided by the Get trait.

Example

use flatk::*;
let mut v = vec![1,2,3,4,0,0,7,8,9,10,11];
let mut s = Chunked::from_offsets(vec![0,3,4,6,9,11], v.as_mut_slice());
s[2].copy_from_slice(&[5,6]);
assert_eq!(vec![1,2,3,4,5,6,7,8,9,10,11], v);

impl<S: IntoFlat, O> IntoFlat for Chunked<S, O>

type FlatType = S::FlatType

fn into_flat(self) -> Self::FlatType

Strip all organizational information from this set, returning the underlying storage type.

Example

use flatk::*;
let v = vec![1,2,3,4,5,6,7,8,9,10,11];
let s0 = Chunked::from_offsets(vec![0,3,4,6,9,11], v.clone());
let s1 = Chunked::from_offsets(vec![0,1,4,5], s0.clone());
assert_eq!(s1.into_flat(), v);
assert_eq!(s0.into_flat(), v);

impl<'a, S> IntoIterator for Chunked<S, Offsets<&'a [usize]>> where
    S: SplitAt + Set + Dummy, 

type Item = S

The type of the elements being iterated over.

type IntoIter = VarIter<'a, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S> IntoIterator for Chunked<S> where
    S: SplitOff + Set, 

type Item = S

The type of the elements being iterated over.

type IntoIter = VarIntoIter<S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S, O> IntoOwned for Chunked<S, O> where
    S: IntoOwned,
    O: IntoOwned, 

type Owned = Chunked<S::Owned, O::Owned>

fn into_owned(self) -> Self::Owned

fn clone_into(self, target: &mut Self::Owned)

impl<S, O> IntoOwnedData for Chunked<S, O> where
    S: IntoOwnedData, 

type OwnedData = Chunked<S::OwnedData, O>

fn into_owned_data(self) -> Self::OwnedData

fn clone_into(self, target: &mut Self::OwnedData)

impl<S, O> IsolateIndex<Chunked<S, O>> for usize where
    S: Set + Isolate<Range<usize>>,
    O: IndexRange, 

type Output = S::Output

fn try_isolate(self, chunked: Chunked<S, O>) -> Option<Self::Output>

Isolate a single chunk of the given Chunked collection.

impl<S, O> IsolateIndex<Chunked<S, O>> for Range<usize> where
    S: Set + Isolate<Range<usize>>,
    <S as Isolate<Range<usize>>>::Output: Set,
    O: IndexRange + Isolate<Range<usize>>, 

type Output = Chunked<S::Output, O::Output>

fn try_isolate(self, chunked: Chunked<S, O>) -> Option<Self::Output>

Isolate a [begin..end) range of the given Chunked collection.

impl<S, O, N: Unsigned> IsolateIndex<Chunked<S, O>> for StaticRange<N> where
    Range<usize>: IsolateIndex<Chunked<S, O>>, 

type Output = <Range<usize> as IsolateIndex<Chunked<S, O>>>::Output

fn try_isolate(self, set: Chunked<S, O>) -> Option<Self::Output>

impl<S: PartialEq, O: PartialEq> PartialEq<Chunked<S, O>> for Chunked<S, O>

fn eq(&self, other: &Chunked<S, O>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Chunked<S, O>) -> bool

This method tests for !=.

impl<S, O, L> Push<L> for Chunked<S, O> where
    S: Set + ExtendFromSlice<Item = <S as Set>::Elem>,
    L: AsRef<[<S as Set>::Elem]>,
    O: Push<usize>, 

fn push(&mut self, element: L)

Push a slice of elements onto this Chunked.

Examples

use flatk::*;
let mut s = Chunked::<Vec<usize>>::from_offsets(vec![0,1,4], vec![0,1,2,3]);
s.push(vec![4,5]);
let v1 = s.view();
let mut view1_iter = v1.into_iter();
assert_eq!(Some(&[0][..]), view1_iter.next());
assert_eq!(Some(&[1,2,3][..]), view1_iter.next());
assert_eq!(Some(&[4,5][..]), view1_iter.next());
assert_eq!(None, view1_iter.next());

use flatk::*;
let mut s = Chunked::from_offsets(vec![0,3,5], vec![1,2,3,4,5]);
assert_eq!(2, s.len());
s.push(&[1,2]);
assert_eq!(3, s.len());

impl<S: RemovePrefix, O: RemovePrefix + AsRef<[usize]>> RemovePrefix for Chunked<S, O>

Required for subsets of chunked collections.

fn remove_prefix(&mut self, n: usize)

Remove a prefix of size n from a chunked collection.

Example

use flatk::*;
let mut s = Chunked::<Vec<usize>>::from_offsets(vec![0,1,4,6], vec![0,1,2,3,4,5]);
s.remove_prefix(2);
let mut iter = s.iter();
assert_eq!(Some(&[4,5][..]), iter.next());
assert_eq!(None, iter.next());

impl<S: Reserve, O: Reserve> Reserve for Chunked<S, O>

fn reserve_with_storage(&mut self, n: usize, storage_n: usize)

fn reserve(&mut self, n: usize)

impl<S, O> Set for Chunked<S, O> where
    S: Set,
    O: Set, 

type Elem = Vec<S::Elem>

Owned element of the set.

type Atom = S::Atom

The most basic element contained by this collection. If this collection contains other collections, this type should be different than Elem.

fn len(&self) -> usize

Get the number of elements in a Chunked.

Example

use flatk::*;
let s = Chunked::from_offsets(vec![0,3,4,6], vec![1,2,3,4,5,6]);
assert_eq!(3, s.len());

fn is_empty(&self) -> bool

impl<S, O> SplitAt for Chunked<S, O> where
    S: SplitAt + Set,
    O: SplitOffsetsAt, 

fn split_at(self, mid: usize) -> (Self, Self)

Split self into two sets at the given midpoint. This function is analogous to <[T]>::split_at.

impl<S, O> SplitFirst for Chunked<S, O> where
    S: Viewed + Set + SplitAt,
    O: Set + SplitOffsetsAt, 

type First = S

fn split_first(self) -> Option<(Self::First, Self)>

impl<S: SplitOff + Set> SplitOff for Chunked<S>

fn split_off(&mut self, mid: usize) -> Self

Split self into two sets at the given midpoint. This function is analogous to Vec::split_off. self contains elements [0, mid), and The returned Self contains elements [mid, len).

impl<S, O, N> SplitPrefix<N> for Chunked<S, O> where
    S: Viewed + Set + SplitAt,
    N: Unsigned,
    O: Set + SplitOffsetsAt, 

type Prefix = Chunked<S, O>

fn split_prefix(self) -> Option<(Self::Prefix, Self)>

impl<S: Storage, O> Storage for Chunked<S, O>

type Storage = S::Storage

fn storage(&self) -> &Self::Storage

Return an immutable reference to the underlying storage type.

Example

use flatk::*;
let v = vec![1,2,3,4,5,6,7,8,9,10,11];
let s0 = Chunked::from_offsets(vec![0,3,4,6,9,11], v.clone());
let s1 = Chunked::from_offsets(vec![0,1,4,5], s0.clone());
assert_eq!(s1.storage(), &v);
assert_eq!(s0.storage(), &v);

impl<S: StorageInto<T>, O, T> StorageInto<T> for Chunked<S, O>

Pass through the conversion for structure type Chunked.

type Output = Chunked<S::Output, O>

fn storage_into(self) -> Self::Output

impl<S: StorageMut, O> StorageMut for Chunked<S, O>

fn storage_mut(&mut self) -> &mut Self::Storage

Return a mutable reference to the underlying storage type.

Example

use flatk::*;
let mut v = vec![1,2,3,4,5,6,7,8,9,10,11];
let mut s0 = Chunked::from_offsets(vec![0,3,4,6,9,11], v.clone());
let mut s1 = Chunked::from_offsets(vec![0,1,4,5], s0.clone());
assert_eq!(s1.storage_mut(), &mut v);
assert_eq!(s0.storage_mut(), &mut v);

impl<'a, S: StorageView<'a>, O> StorageView<'a> for Chunked<S, O>

type StorageView = S::StorageView

fn storage_view(&'a self) -> Self::StorageView

Return a view to the underlying storage type.

Example

use flatk::*;
let v = vec![1,2,3,4,5,6,7,8,9,10,11];
let s0 = Chunked::from_offsets(vec![0,3,4,6,9,11], v.clone());
let s1 = Chunked::from_offsets(vec![0,1,4,5], s0.clone());
assert_eq!(s1.storage_view(), v.as_slice());
assert_eq!(s0.storage_view(), v.as_slice());

impl<S, O> StructuralPartialEq for Chunked<S, O>

impl<S: Truncate, O> Truncate for Chunked<S, O> where
    O: AsRef<[usize]>, 

fn truncate(&mut self, new_len: usize)

impl<S, I, N> UniChunkable<N> for Chunked<S, I>

type Chunk = Chunked<S, I>

impl<S, I> ValueType for Chunked<S, I>

impl<'a, S, O> View<'a> for Chunked<S, O> where
    S: View<'a>,
    O: View<'a>, 

type Type = Chunked<S::Type, O::Type>

fn view(&'a self) -> Self::Type

Create a contiguous immutable (shareable) view into this set.

Example

use flatk::*;
let s = Chunked::<Vec<usize>>::from_offsets(vec![0,1,4,6], vec![0,1,2,3,4,5]);
let v1 = s.view();
let v2 = v1.clone();
let mut view1_iter = v1.clone().into_iter();
assert_eq!(Some(&[0][..]), view1_iter.next());
assert_eq!(Some(&[1,2,3][..]), view1_iter.next());
assert_eq!(Some(&[4,5][..]), view1_iter.next());
assert_eq!(None, view1_iter.next());
for (a,b) in v1.into_iter().zip(v2.into_iter()) {
    assert_eq!(a,b);
}

impl<'a, S, O> ViewIterator<'a> for Chunked<S, O> where
    S: View<'a>,
    O: View<'a, Type = Offsets<&'a [usize]>>,
    <S as View<'a>>::Type: SplitAt + Set + Dummy, 

type Item = <S as View<'a>>::Type

type Iter = VarIter<'a, <S as View<'a>>::Type>

fn view_iter(&'a self) -> Self::Iter

impl<'a, S, O> ViewMut<'a> for Chunked<S, O> where
    S: ViewMut<'a>,
    O: View<'a>, 

type Type = Chunked<S::Type, O::Type>

fn view_mut(&'a mut self) -> Self::Type

Create a contiguous mutable (unique) view into this set.

Example

use flatk::*;
let mut s = Chunked::<Vec<usize>>::from_offsets(vec![0,1,4,6], vec![0,1,2,3,4,5]);
let mut v1 = s.view_mut();
v1.iter_mut().next().unwrap()[0] = 100;
let mut view1_iter = v1.iter();
assert_eq!(Some(&[100][..]), view1_iter.next());
assert_eq!(Some(&[1,2,3][..]), view1_iter.next());
assert_eq!(Some(&[4,5][..]), view1_iter.next());
assert_eq!(None, view1_iter.next());

impl<'a, S, O> ViewMutIterator<'a> for Chunked<S, O> where
    S: ViewMut<'a>,
    O: View<'a, Type = Offsets<&'a [usize]>>,
    <S as ViewMut<'a>>::Type: SplitAt + Set + Dummy, 

type Item = <S as ViewMut<'a>>::Type

type Iter = VarIter<'a, <S as ViewMut<'a>>::Type>

fn view_mut_iter(&'a mut self) -> Self::Iter

impl<S: Viewed, I: Viewed> Viewed for Chunked<S, I>