Trait ArbitraryChunks 

pub trait ArbitraryChunks<'a, 'b, T> {
    // Required methods
    fn arbitrary_chunks(
        &'a self,
        counts: &'b [usize],
    ) -> ArbitraryChunk<'a, 'b, T> ;
    fn arbitrary_chunks_mut(
        &'a mut self,
        counts: &'b [usize],
    ) -> ArbitraryChunkMut<'a, 'b, T> ;
    fn arbitrary_chunks_exact(
        &'a self,
        counts: &'b [usize],
    ) -> ArbitraryChunkExact<'a, 'b, T> ;
    fn arbitrary_chunks_exact_mut(
        &'a mut self,
        counts: &'b [usize],
    ) -> ArbitraryChunkExactMut<'a, 'b, T> ;
}

Required Methods

fn arbitrary_chunks(&'a self, counts: &'b [usize]) -> ArbitraryChunk<'a, 'b, T>

arbitrary_chunks returns an iterator over chunks of sizes defined in counts.

use arbitrary_chunks::ArbitraryChunks;

let chunks: Vec<usize> = vec![1, 3, 1];
let data: Vec<i32> = vec![0, 1, 2, 3, 4];

let chunked_data: Vec<Vec<i32>> = data
    .arbitrary_chunks(&chunks)
    .map(|chunk| chunk.to_vec())
    .collect();

assert_eq!(vec![0], chunked_data[0]);
assert_eq!(vec![1, 2, 3], chunked_data[1]);
assert_eq!(vec![4], chunked_data[2]);

fn arbitrary_chunks_mut( &'a mut self, counts: &'b [usize], ) -> ArbitraryChunkMut<'a, 'b, T>

arbitrary_chunks_mut returns an iterator over mutable chunks of sizes defined in counts.

use arbitrary_chunks::ArbitraryChunks;

let chunks: Vec<usize> = vec![1, 3, 1];
let mut data: Vec<i32> = vec![0, 1, 2, 3, 4];

data
    .arbitrary_chunks_mut(&chunks)
    .for_each(|chunk| {
        chunk[0] = chunk[0] * 2;
    });

assert_eq!(vec![0, 2, 2, 3, 8], data);

fn arbitrary_chunks_exact( &'a self, counts: &'b [usize], ) -> ArbitraryChunkExact<'a, 'b, T>

arbitrary_chunks_exact returns chunks sized exactly as requested, or not at all. If there is not enough data to satisfy the chunk, the iterator will end. You will then be able to get the remainder of the data using .remainder() on the iterator.

use arbitrary_chunks::ArbitraryChunks;

let chunks: Vec<usize> = vec![1, 3];
let data: Vec<i32> = vec![0, 1, 2];
let mut iter = data.arbitrary_chunks_exact(&chunks);

assert_eq!(vec![0], iter.next().unwrap());
assert_eq!(None, iter.next());
assert_eq!(vec![1, 2], iter.remainder());

fn arbitrary_chunks_exact_mut( &'a mut self, counts: &'b [usize], ) -> ArbitraryChunkExactMut<'a, 'b, T>

arbitrary_chunks_exact_mut returns chunks sized exactly as requested, or not at all. If there is not enough data to satisfy the chunk, the iterator will end. You will then be able to get the remainder of the data using .remainder() on the iterator.

use arbitrary_chunks::ArbitraryChunks;

let chunks: Vec<usize> = vec![1, 3];
let mut data: Vec<i32> = vec![0, 1, 2];
let mut iter = data.arbitrary_chunks_exact_mut(&chunks);

assert_eq!(vec![0], iter.next().unwrap());
assert_eq!(None, iter.next());
assert_eq!(vec![1, 2], iter.remainder());

Implementations on Foreign Types

impl<'a, 'b, T> ArbitraryChunks<'a, 'b, T> for [T]

fn arbitrary_chunks(&'a self, counts: &'b [usize]) -> ArbitraryChunk<'a, 'b, T>

fn arbitrary_chunks_mut( &'a mut self, counts: &'b [usize], ) -> ArbitraryChunkMut<'a, 'b, T>

fn arbitrary_chunks_exact( &'a self, counts: &'b [usize], ) -> ArbitraryChunkExact<'a, 'b, T>

fn arbitrary_chunks_exact_mut( &'a mut self, counts: &'b [usize], ) -> ArbitraryChunkExactMut<'a, 'b, T>

Implementors