Trait arbitrary_chunks::ArbitraryChunks[−][src]

pub trait ArbitraryChunks<T> {
    fn arbitrary_chunks(&self, counts: Vec<usize>) -> ArbitraryChunk<'_, T>ⓘ
Notable traits for ArbitraryChunk<'a, T>
impl<'a, T> Iterator for ArbitraryChunk<'a, T>    type Item = &'a [T];
;

    fn arbitrary_chunks_mut(
        &mut self, 
        counts: Vec<usize>
    ) -> ArbitraryChunkMut<'_, T>ⓘ
Notable traits for ArbitraryChunkMut<'a, T>
impl<'a, T> Iterator for ArbitraryChunkMut<'a, T>    type Item = &'a mut [T];
;

    fn arbitrary_chunks_exact(
        &self, 
        counts: Vec<usize>
    ) -> ArbitraryChunkExact<'_, T>ⓘ
Notable traits for ArbitraryChunkExact<'a, T>
impl<'a, T> Iterator for ArbitraryChunkExact<'a, T>    type Item = &'a [T];
;

    fn arbitrary_chunks_exact_mut(
        &mut self, 
        counts: Vec<usize>
    ) -> ArbitraryChunkExactMut<'_, T>ⓘ
Notable traits for ArbitraryChunkExactMut<'a, T>
impl<'a, T> Iterator for ArbitraryChunkExactMut<'a, T>    type Item = &'a mut [T];
;
}

Required methods

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]);

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);

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());

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

Implementors