Struct rayon::slice::ChunksExactMut
source · pub struct ChunksExactMut<'data, T: Send> {
chunk_size: usize,
slice: &'data mut [T],
rem: &'data mut [T],
}
Expand description
Parallel iterator over mutable non-overlapping chunks of a slice
Fields§
§chunk_size: usize
§slice: &'data mut [T]
§rem: &'data mut [T]
Implementations§
source§impl<'data, T: Send> ChunksExactMut<'data, T>
impl<'data, T: Send> ChunksExactMut<'data, T>
pub(super) fn new(chunk_size: usize, slice: &'data mut [T]) -> Self
sourcepub fn into_remainder(self) -> &'data mut [T]
pub fn into_remainder(self) -> &'data mut [T]
Return the remainder of the original slice that is not going to be
returned by the iterator. The returned slice has at most chunk_size-1
elements.
Note that this has to consume self
to return the original lifetime of
the data, which prevents this from actually being used as a parallel
iterator since that also consumes. This method is provided for parity
with std::iter::ChunksExactMut
, but consider calling remainder()
or
take_remainder()
as alternatives.
sourcepub fn remainder(&mut self) -> &mut [T]
pub fn remainder(&mut self) -> &mut [T]
Return the remainder of the original slice that is not going to be
returned by the iterator. The returned slice has at most chunk_size-1
elements.
Consider take_remainder()
if you need access to the data with its
original lifetime, rather than borrowing through &mut self
here.
sourcepub fn take_remainder(&mut self) -> &'data mut [T]
pub fn take_remainder(&mut self) -> &'data mut [T]
Return the remainder of the original slice that is not going to be
returned by the iterator. The returned slice has at most chunk_size-1
elements. Subsequent calls will return an empty slice.
Trait Implementations§
source§impl<'data, T: Send + 'data> IndexedParallelIterator for ChunksExactMut<'data, T>
impl<'data, T: Send + 'data> IndexedParallelIterator for ChunksExactMut<'data, T>
source§fn drive<C>(self, consumer: C) -> C::Result
fn drive<C>(self, consumer: C) -> C::Result
source§fn len(&self) -> usize
fn len(&self) -> usize
source§fn with_producer<CB>(self, callback: CB) -> CB::Outputwhere
CB: ProducerCallback<Self::Item>,
fn with_producer<CB>(self, callback: CB) -> CB::Outputwhere
CB: ProducerCallback<Self::Item>,
source§fn by_exponential_blocks(self) -> ExponentialBlocks<Self>
fn by_exponential_blocks(self) -> ExponentialBlocks<Self>
source§fn by_uniform_blocks(self, block_size: usize) -> UniformBlocks<Self>
fn by_uniform_blocks(self, block_size: usize) -> UniformBlocks<Self>
source§fn collect_into_vec(self, target: &mut Vec<Self::Item>)
fn collect_into_vec(self, target: &mut Vec<Self::Item>)
source§fn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec<B>)
fn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec<B>)
source§fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter>
fn zip<Z>(self, zip_op: Z) -> Zip<Self, Z::Iter>
(A, B)
, where the items A
are from
this iterator and B
are from the iterator given as argument.
Like the zip
method on ordinary iterators, if the two
iterators are of unequal length, you only get the items they
have in common. Read moresource§fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter>
fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, Z::Iter>
Zip
, but requires that both iterators have the same length. Read moresource§fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave<I>(self, other: I) -> Interleave<Self, I::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
source§fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
fn interleave_shortest<I>(self, other: I) -> InterleaveShortest<Self, I::Iter>where
I: IntoParallelIterator<Item = Self::Item>,
I::Iter: IndexedParallelIterator<Item = Self::Item>,
source§fn chunks(self, chunk_size: usize) -> Chunks<Self>
fn chunks(self, chunk_size: usize) -> Chunks<Self>
source§fn fold_chunks<T, ID, F>(
self,
chunk_size: usize,
identity: ID,
fold_op: F,
) -> FoldChunks<Self, ID, F>
fn fold_chunks<T, ID, F>( self, chunk_size: usize, identity: ID, fold_op: F, ) -> FoldChunks<Self, ID, F>
source§fn fold_chunks_with<T, F>(
self,
chunk_size: usize,
init: T,
fold_op: F,
) -> FoldChunksWith<Self, T, F>
fn fold_chunks_with<T, F>( self, chunk_size: usize, init: T, fold_op: F, ) -> FoldChunksWith<Self, T, F>
source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
ParallelIterator
with those of
another. Read moresource§fn eq<I>(self, other: I) -> bool
fn eq<I>(self, other: I) -> bool
ParallelIterator
are equal to those of anothersource§fn ne<I>(self, other: I) -> bool
fn ne<I>(self, other: I) -> bool
ParallelIterator
are unequal to those of anothersource§fn lt<I>(self, other: I) -> bool
fn lt<I>(self, other: I) -> bool
ParallelIterator
are lexicographically less than those of another.source§fn le<I>(self, other: I) -> bool
fn le<I>(self, other: I) -> bool
ParallelIterator
are less or equal to those of another.source§fn gt<I>(self, other: I) -> bool
fn gt<I>(self, other: I) -> bool
ParallelIterator
are lexicographically greater than those of another.source§fn ge<I>(self, other: I) -> bool
fn ge<I>(self, other: I) -> bool
ParallelIterator
are less or equal to those of another.source§fn step_by(self, step: usize) -> StepBy<Self>
fn step_by(self, step: usize) -> StepBy<Self>
source§fn skip(self, n: usize) -> Skip<Self>
fn skip(self, n: usize) -> Skip<Self>
n
elements. Read moresource§fn take(self, n: usize) -> Take<Self>
fn take(self, n: usize) -> Take<Self>
n
elements. Read moresource§fn position_any<P>(self, predicate: P) -> Option<usize>
fn position_any<P>(self, predicate: P) -> Option<usize>
ParallelIterator::find_any
, the parallel search will not
necessarily find the first match, and once a match is
found we’ll attempt to stop processing any more. Read moresource§fn position_first<P>(self, predicate: P) -> Option<usize>
fn position_first<P>(self, predicate: P) -> Option<usize>
source§fn position_last<P>(self, predicate: P) -> Option<usize>
fn position_last<P>(self, predicate: P) -> Option<usize>
source§fn positions<P>(self, predicate: P) -> Positions<Self, P>
fn positions<P>(self, predicate: P) -> Positions<Self, P>
source§fn rev(self) -> Rev<Self>
fn rev(self) -> Rev<Self>
source§fn with_min_len(self, min: usize) -> MinLen<Self>
fn with_min_len(self, min: usize) -> MinLen<Self>
source§fn with_max_len(self, max: usize) -> MaxLen<Self>
fn with_max_len(self, max: usize) -> MaxLen<Self>
with_min_len()
.
For example, given min=10 and max=15, a length of 16 will not be
split any further. Read moresource§impl<'data, T: Send + 'data> ParallelIterator for ChunksExactMut<'data, T>
impl<'data, T: Send + 'data> ParallelIterator for ChunksExactMut<'data, T>
source§type Item = &'data mut [T]
type Item = &'data mut [T]
for_each
method, this is the type of
item that your closure will be invoked with.source§fn drive_unindexed<C>(self, consumer: C) -> C::Resultwhere
C: UnindexedConsumer<Self::Item>,
fn drive_unindexed<C>(self, consumer: C) -> C::Resultwhere
C: UnindexedConsumer<Self::Item>,
source§fn opt_len(&self) -> Option<usize>
fn opt_len(&self) -> Option<usize>
source§fn for_each<OP>(self, op: OP)
fn for_each<OP>(self, op: OP)
OP
on each item produced by the iterator, in parallel. Read moresource§fn for_each_with<OP, T>(self, init: T, op: OP)
fn for_each_with<OP, T>(self, init: T, op: OP)
source§fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)
OP
on a value returned by init
with each item produced by
the iterator, in parallel. Read moresource§fn try_for_each<OP, R>(self, op: OP) -> R
fn try_for_each<OP, R>(self, op: OP) -> R
OP
on each item produced by the iterator, in parallel. Read moresource§fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R
OP
on the given init
value with each item
produced by the iterator, in parallel. Read moresource§fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R
OP
on a value returned by init
with each item
produced by the iterator, in parallel. Read moresource§fn map<F, R>(self, map_op: F) -> Map<Self, F>
fn map<F, R>(self, map_op: F) -> Map<Self, F>
map_op
to each item of this iterator, producing a new
iterator with the results. Read moresource§fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>
map_op
to the given init
value with each item of this
iterator, producing a new iterator with the results. Read moresource§fn map_init<F, INIT, T, R>(
self,
init: INIT,
map_op: F,
) -> MapInit<Self, INIT, F>
fn map_init<F, INIT, T, R>( self, init: INIT, map_op: F, ) -> MapInit<Self, INIT, F>
map_op
to a value returned by init
with each item of this
iterator, producing a new iterator with the results. Read moresource§fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>
inspect_op
to a reference to each item of this iterator,
producing a new iterator passing through the original items. This is
often useful for debugging to see what’s happening in iterator stages. Read moresource§fn update<F>(self, update_op: F) -> Update<Self, F>
fn update<F>(self, update_op: F) -> Update<Self, F>
source§fn filter<P>(self, filter_op: P) -> Filter<Self, P>
fn filter<P>(self, filter_op: P) -> Filter<Self, P>
filter_op
to each item of this iterator, producing a new
iterator with only the items that gave true
results. Read moresource§fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>
filter_op
to each item of this iterator to get an Option
,
producing a new iterator with only the items from Some
results. Read moresource§fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>
map_op
to each item of this iterator to get nested parallel iterators,
producing a new parallel iterator that flattens these back into one. Read moresource§fn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>
fn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>
map_op
to each item of this iterator to get nested serial iterators,
producing a new parallel iterator that flattens these back into one. Read moresource§fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item
op
.
The argument identity
should be a closure that can produce
“identity” value which may be inserted into the sequence as
needed to create opportunities for parallel execution. So, for
example, if you are doing a summation, then identity()
ought
to produce something that represents the zero for your type
(but consider just calling sum()
in that case). Read moresource§fn reduce_with<OP>(self, op: OP) -> Option<Self::Item>
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item>
op
.
If the iterator is empty, None
is returned; otherwise,
Some
is returned. Read moresource§fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>
22 3 77 89 46
. If
you used sequential fold to add them (fold(0, |a,b| a+b)
,
you would wind up first adding 0 + 22, then 22 + 3, then 25 +
77, and so forth. The parallel fold works similarly except
that it first breaks up your list into sublists, and hence
instead of yielding up a single sum at the end, it yields up
multiple sums. The number of results is nondeterministic, as
is the point where the breaks occur. Read moresource§fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>
fold_op
to the given init
value with each item of this
iterator, finally producing the value for further use. Read moresource§fn try_fold<T, R, ID, F>(
self,
identity: ID,
fold_op: F,
) -> TryFold<Self, R, ID, F>
fn try_fold<T, R, ID, F>( self, identity: ID, fold_op: F, ) -> TryFold<Self, R, ID, F>
source§fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F>
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F>
init
value. Read moresource§fn min_by<F>(self, f: F) -> Option<Self::Item>
fn min_by<F>(self, f: F) -> Option<Self::Item>
None
is
returned; otherwise, Some(min)
is returned. Read moresource§fn min_by_key<K, F>(self, f: F) -> Option<Self::Item>
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item>
None
is returned;
otherwise, Some(item)
is returned. Read moresource§fn max_by<F>(self, f: F) -> Option<Self::Item>
fn max_by<F>(self, f: F) -> Option<Self::Item>
None
is
returned; otherwise, Some(max)
is returned. Read moresource§fn max_by_key<K, F>(self, f: F) -> Option<Self::Item>
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item>
None
is returned;
otherwise, Some(item)
is returned. Read moresource§fn chain<C>(self, chain: C) -> Chain<Self, C::Iter>where
C: IntoParallelIterator<Item = Self::Item>,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter>where
C: IntoParallelIterator<Item = Self::Item>,
source§fn find_any<P>(self, predicate: P) -> Option<Self::Item>
fn find_any<P>(self, predicate: P) -> Option<Self::Item>
find
on sequential iterators but
the item returned may not be the first one in the parallel
sequence which matches, since we search the entire sequence in parallel. Read moresource§fn find_first<P>(self, predicate: P) -> Option<Self::Item>
fn find_first<P>(self, predicate: P) -> Option<Self::Item>
source§fn find_last<P>(self, predicate: P) -> Option<Self::Item>
fn find_last<P>(self, predicate: P) -> Option<Self::Item>
source§fn find_map_any<P, R>(self, predicate: P) -> Option<R>
fn find_map_any<P, R>(self, predicate: P) -> Option<R>
source§fn find_map_first<P, R>(self, predicate: P) -> Option<R>
fn find_map_first<P, R>(self, predicate: P) -> Option<R>
source§fn find_map_last<P, R>(self, predicate: P) -> Option<R>
fn find_map_last<P, R>(self, predicate: P) -> Option<R>
source§fn any<P>(self, predicate: P) -> bool
fn any<P>(self, predicate: P) -> bool
source§fn all<P>(self, predicate: P) -> bool
fn all<P>(self, predicate: P) -> bool
source§fn while_some<T>(self) -> WhileSome<Self>
fn while_some<T>(self) -> WhileSome<Self>
Some
items of this iterator, halting
as soon as any None
is found. Read moresource§fn panic_fuse(self) -> PanicFuse<Self>
fn panic_fuse(self) -> PanicFuse<Self>
source§fn collect<C>(self) -> Cwhere
C: FromParallelIterator<Self::Item>,
fn collect<C>(self) -> Cwhere
C: FromParallelIterator<Self::Item>,
source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: Send,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: Send,
ParallelExtend
containers. Read moresource§fn partition<A, B, P>(self, predicate: P) -> (A, B)
fn partition<A, B, P>(self, predicate: P) -> (A, B)
ParallelExtend
containers. Items for which the predicate
returns
true go into the first container, and the rest go into the second. Read moresource§fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)
ParallelExtend
containers. Either::Left
items go into
the first container, and Either::Right
items go into the second. Read moresource§fn take_any(self, n: usize) -> TakeAny<Self>
fn take_any(self, n: usize) -> TakeAny<Self>
n
elements from anywhere in the original iterator. Read moresource§fn skip_any(self, n: usize) -> SkipAny<Self>
fn skip_any(self, n: usize) -> SkipAny<Self>
n
elements from anywhere in the original iterator. Read moresource§fn take_any_while<P>(self, predicate: P) -> TakeAnyWhile<Self, P>
fn take_any_while<P>(self, predicate: P) -> TakeAnyWhile<Self, P>
predicate
returns false
. Read moresource§fn skip_any_while<P>(self, predicate: P) -> SkipAnyWhile<Self, P>
fn skip_any_while<P>(self, predicate: P) -> SkipAnyWhile<Self, P>
predicate
returns false
. Read moresource§fn collect_vec_list(self) -> LinkedList<Vec<Self::Item>>
fn collect_vec_list(self) -> LinkedList<Vec<Self::Item>>
Auto Trait Implementations§
impl<'data, T> Freeze for ChunksExactMut<'data, T>
impl<'data, T> RefUnwindSafe for ChunksExactMut<'data, T>where
T: RefUnwindSafe,
impl<'data, T> Send for ChunksExactMut<'data, T>
impl<'data, T> Sync for ChunksExactMut<'data, T>where
T: Sync,
impl<'data, T> Unpin for ChunksExactMut<'data, T>
impl<'data, T> !UnwindSafe for ChunksExactMut<'data, T>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more