Trait flatk::Push

pub trait Push<T> {
    fn push(&mut self, element: T);
}

Abstraction for pushing elements of type T onto a collection.

Required methods

fn push(&mut self, element: T)

Loading content...

Implementations on Foreign Types

impl<A, B, S: Push<A>, T: Push<B>> Push<(A, B)> for (S, T)

fn push(&mut self, (a, b): (A, B))

impl<T> Push<T> for Vec<T>

fn push(&mut self, element: T)

Loading content...

Implementors

impl<'_, S> Push<&'_ [<S as Set>::Elem]> for ChunkedN<S> where
    S: Set + Push<<S as Set>::Elem>,
    <S as Set>::Elem: Clone, 

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

Push a grouped element onto the ChunkedN type.

Example

use flatk::*;
let mut s = ChunkedN::from_flat_with_stride(vec![1,2,3], 3);
s.push(&[4,5,6]);
let mut iter = s.iter();
assert_eq!(Some(&[1,2,3][..]), iter.next());
assert_eq!(Some(&[4,5,6][..]), iter.next());
assert_eq!(None, iter.next());

impl<'a, S, N> Push<<S as UniChunkable<N>>::Chunk> for UniChunked<S, U<N>> where
    N: Unsigned,
    S: Set + UniChunkable<N> + PushChunk<N>, 

fn push(&mut self, element: S::Chunk)

Push a grouped element onto the UniChunked type. The pushed element must have exactly N sub-elements.

Example

use flatk::*;
let mut s = UniChunked::<_, U3>::from_flat(vec![1,2,3]);
s.push([4,5,6]);
let mut iter = s.iter();
assert_eq!(Some(&[1,2,3]), iter.next());
assert_eq!(Some(&[4,5,6]), iter.next());
assert_eq!(None, iter.next());

impl<O: Push<usize>> Push<usize> for Offsets<O>

fn push(&mut self, item: usize)

impl<O: Push<usize>> Push<usize> for SortedChunks<O>

fn push(&mut self, item: usize)

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, T, I, A> Push<(usize, A)> for Sparse<S, T, I> where
    S: Set<Elem = A> + Push<A>,
    I: Push<usize>, 

fn push(&mut self, (index, elem): (usize, A))

Loading content...