Struct rayon::str::SplitTerminator [−][src]
Parallel iterator over substrings separated by a terminator pattern
Trait Implementations
impl<'ch, P: Clone + Pattern> Clone for SplitTerminator<'ch, P>
[src]
fn clone(&self) -> SplitTerminator<'ch, P>
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<'ch, P: Debug + Pattern> Debug for SplitTerminator<'ch, P>
[src]
impl<'ch, P: Pattern> ParallelIterator for SplitTerminator<'ch, P>
[src]
type Item = &'ch str
The type of item that this parallel iterator produces.
For example, if you use the for_each
method, this is the type of
item that your closure will be invoked with. Read more
fn drive_unindexed<C>(self, consumer: C) -> C::Result where
C: UnindexedConsumer<Self::Item>,
[src]
C: UnindexedConsumer<Self::Item>,
fn for_each<OP>(self, op: OP) where
OP: Fn(Self::Item) + Sync + Send,
[src]
OP: Fn(Self::Item) + Sync + Send,
fn for_each_with<OP, T>(self, init: T, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
T: Send + Clone,
fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP) where
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
[src]
OP: Fn(&mut T, Self::Item) + Sync + Send,
INIT: Fn() -> T + Sync + Send,
fn try_for_each<OP, R>(self, op: OP) -> R where
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(Self::Item) -> R + Sync + Send,
R: Try<Ok = ()> + Send,
fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R where
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Try<Ok = ()> + Send,
fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R where
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
[src]
OP: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Try<Ok = ()> + Send,
fn count(self) -> usize
[src]
fn map<F, R>(self, map_op: F) -> Map<Self, F> where
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
[src]
F: Fn(Self::Item) -> R + Sync + Send,
R: Send,
fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F> where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Send,
[src]
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
T: Send + Clone,
R: Send,
fn map_init<F, INIT, T, R>(
self,
init: INIT,
map_op: F
) -> MapInit<Self, INIT, F> where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Send,
[src]
self,
init: INIT,
map_op: F
) -> MapInit<Self, INIT, F> where
F: Fn(&mut T, Self::Item) -> R + Sync + Send,
INIT: Fn() -> T + Sync + Send,
R: Send,
fn cloned<'a, T>(self) -> Cloned<Self> where
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
T: 'a + Clone + Send,
Self: ParallelIterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self> where
T: 'a + Copy + Send,
Self: ParallelIterator<Item = &'a T>,
[src]
T: 'a + Copy + Send,
Self: ParallelIterator<Item = &'a T>,
fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP> where
OP: Fn(&Self::Item) + Sync + Send,
[src]
OP: Fn(&Self::Item) + Sync + Send,
fn update<F>(self, update_op: F) -> Update<Self, F> where
F: Fn(&mut Self::Item) + Sync + Send,
[src]
F: Fn(&mut Self::Item) + Sync + Send,
fn filter<P>(self, filter_op: P) -> Filter<Self, P> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F> where
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
[src]
F: Fn(Self::Item) -> PI + Sync + Send,
PI: IntoParallelIterator,
fn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F> where
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
[src]
F: Fn(Self::Item) -> SI + Sync + Send,
SI: IntoIterator,
SI::Item: Send,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoParallelIterator,
[src]
Self::Item: IntoParallelIterator,
fn flatten_iter(self) -> FlattenIter<Self> where
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
[src]
Self::Item: IntoIterator,
<Self::Item as IntoIterator>::Item: Send,
fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item where
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> Self::Item + Sync + Send,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
ID: Fn() -> Self::Item + Sync + Send,
fn reduce_with<OP>(self, op: OP) -> Option<Self::Item> where
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
[src]
OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,
fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item where
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
[src]
OP: Fn(T, T) -> Self::Item + Sync + Send,
ID: Fn() -> T + Sync + Send,
Self::Item: Try<Ok = T>,
fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item> where
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
[src]
OP: Fn(T, T) -> Self::Item + Sync + Send,
Self::Item: Try<Ok = T>,
fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F> where
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
[src]
F: Fn(T, Self::Item) -> T + Sync + Send,
ID: Fn() -> T + Sync + Send,
T: Send,
fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F> where
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
[src]
F: Fn(T, Self::Item) -> T + Sync + Send,
T: Send + Clone,
fn try_fold<T, R, ID, F>(
self,
identity: ID,
fold_op: F
) -> TryFold<Self, R, ID, F> where
F: Fn(T, Self::Item) -> R + Sync + Send,
ID: Fn() -> T + Sync + Send,
R: Try<Ok = T> + Send,
[src]
self,
identity: ID,
fold_op: F
) -> TryFold<Self, R, ID, F> where
F: Fn(T, Self::Item) -> R + Sync + Send,
ID: Fn() -> T + Sync + Send,
R: Try<Ok = T> + Send,
fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F> where
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
[src]
F: Fn(T, Self::Item) -> R + Sync + Send,
R: Try<Ok = T> + Send,
T: Clone + Send,
fn sum<S>(self) -> S where
S: Send + Sum<Self::Item> + Sum<S>,
[src]
S: Send + Sum<Self::Item> + Sum<S>,
fn product<P>(self) -> P where
P: Send + Product<Self::Item> + Product<P>,
[src]
P: Send + Product<Self::Item> + Product<P>,
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn min_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
Self::Item: Ord,
fn max_by<F>(self, f: F) -> Option<Self::Item> where
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
[src]
F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,
fn max_by_key<K, F>(self, f: F) -> Option<Self::Item> where
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
[src]
K: Ord + Send,
F: Sync + Send + Fn(&Self::Item) -> K,
fn chain<C>(self, chain: C) -> Chain<Self, C::Iter> where
C: IntoParallelIterator<Item = Self::Item>,
[src]
C: IntoParallelIterator<Item = Self::Item>,
fn find_any<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn find_first<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn find_last<P>(self, predicate: P) -> Option<Self::Item> where
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
P: Fn(&Self::Item) -> bool + Sync + Send,
fn find_map_any<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn find_map_first<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn find_map_last<P, R>(self, predicate: P) -> Option<R> where
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
[src]
P: Fn(Self::Item) -> Option<R> + Sync + Send,
R: Send,
fn any<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn all<P>(self, predicate: P) -> bool where
P: Fn(Self::Item) -> bool + Sync + Send,
[src]
P: Fn(Self::Item) -> bool + Sync + Send,
fn while_some<T>(self) -> WhileSome<Self> where
Self: ParallelIterator<Item = Option<T>>,
T: Send,
[src]
Self: ParallelIterator<Item = Option<T>>,
T: Send,
fn panic_fuse(self) -> PanicFuse<Self>
[src]
fn collect<C>(self) -> C where
C: FromParallelIterator<Self::Item>,
[src]
C: FromParallelIterator<Self::Item>,
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,
[src]
Self: ParallelIterator<Item = (A, B)>,
FromA: Default + Send + ParallelExtend<A>,
FromB: Default + Send + ParallelExtend<B>,
A: Send,
B: Send,
fn partition<A, B, P>(self, predicate: P) -> (A, B) where
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + Send,
[src]
A: Default + Send + ParallelExtend<Self::Item>,
B: Default + Send + ParallelExtend<Self::Item>,
P: Fn(&Self::Item) -> bool + Sync + Send,
fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B) where
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
[src]
A: Default + Send + ParallelExtend<L>,
B: Default + Send + ParallelExtend<R>,
P: Fn(Self::Item) -> Either<L, R> + Sync + Send,
L: Send,
R: Send,
fn intersperse(self, element: Self::Item) -> Intersperse<Self> where
Self::Item: Clone,
[src]
Self::Item: Clone,
fn opt_len(&self) -> Option<usize>
[src]
Auto Trait Implementations
impl<'ch, P> RefUnwindSafe for SplitTerminator<'ch, P> where
P: RefUnwindSafe,
P: RefUnwindSafe,
impl<'ch, P> Send for SplitTerminator<'ch, P>
impl<'ch, P> Sync for SplitTerminator<'ch, P>
impl<'ch, P> Unpin for SplitTerminator<'ch, P> where
P: Unpin,
P: Unpin,
impl<'ch, P> UnwindSafe for SplitTerminator<'ch, P> where
P: UnwindSafe,
P: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> IntoParallelIterator for T where
T: ParallelIterator,
[src]
T: ParallelIterator,
type Iter = T
The parallel iterator type that will be created.
type Item = <T as ParallelIterator>::Item
The type of item that the parallel iterator will produce.
pub fn into_par_iter(Self) -> T
[src]
impl<T> Pointable for T
[src]
pub const ALIGN: usize
[src]
type Init = T
The type for initializers.
pub unsafe fn init(init: <T as Pointable>::Init) -> usize
[src]
pub unsafe fn deref<'a>(ptr: usize) -> &'a T
[src]
pub unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
[src]
pub unsafe fn drop(ptr: usize)
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,