orx_parallel/generic_iterator/
transformations.rs

1use super::iter::GenericIterator;
2use crate::ParIter;
3
4impl<T, S, R, O> GenericIterator<T, S, R, O>
5where
6    T: Send + Sync,
7    S: Iterator<Item = T>,
8    R: rayon::iter::ParallelIterator<Item = T>,
9    O: ParIter<Item = T>,
10{
11    // computation transformations
12
13    /// Map transformation for the generic iterator.
14    ///
15    /// See [`map`] for details.
16    ///
17    /// [`map`]: crate::ParIter::map
18    pub fn map<Out, Map>(
19        self,
20        map: Map,
21    ) -> GenericIterator<
22        Out,
23        impl Iterator<Item = Out>,
24        impl rayon::iter::ParallelIterator<Item = Out>,
25        impl ParIter<Item = Out>,
26    >
27    where
28        Out: Send + Sync,
29        Map: Fn(T) -> Out + Send + Sync + Clone,
30    {
31        match self {
32            GenericIterator::Sequential(x) => GenericIterator::Sequential(x.map(map)),
33            GenericIterator::Rayon(x) => GenericIterator::Rayon(x.map(map)),
34            GenericIterator::Orx(x) => GenericIterator::Orx(x.map(map)),
35        }
36    }
37
38    /// Filter transformation for the generic iterator.
39    ///
40    /// See [`filter`] for details.
41    ///
42    /// [`filter`]: crate::ParIter::filter
43    pub fn filter<Filter>(
44        self,
45        filter: Filter,
46    ) -> GenericIterator<
47        T,
48        impl Iterator<Item = T>,
49        impl rayon::iter::ParallelIterator<Item = T>,
50        impl ParIter<Item = T>,
51    >
52    where
53        Filter: Fn(&T) -> bool + Send + Sync + Clone,
54    {
55        match self {
56            GenericIterator::Sequential(x) => GenericIterator::Sequential(x.filter(filter)),
57            GenericIterator::Rayon(x) => GenericIterator::Rayon(x.filter(filter)),
58            GenericIterator::Orx(x) => GenericIterator::Orx(x.filter(filter)),
59        }
60    }
61
62    /// Flat-map transformation for the generic iterator.
63    ///
64    /// See [`flat_map`] for details.
65    ///
66    /// [`flat_map`]: crate::ParIter::flat_map
67    pub fn flat_map<IOut, FlatMap>(
68        self,
69        flat_map: FlatMap,
70    ) -> GenericIterator<
71        <IOut as IntoIterator>::Item,
72        impl Iterator<Item = <IOut as IntoIterator>::Item>,
73        impl rayon::iter::ParallelIterator<Item = <IOut as IntoIterator>::Item>,
74        impl ParIter<Item = <IOut as IntoIterator>::Item>,
75    >
76    where
77        IOut: IntoIterator
78            + Send
79            + Sync
80            + rayon::iter::IntoParallelIterator<Item = <IOut as IntoIterator>::Item>,
81        <IOut as IntoIterator>::IntoIter: Send + Sync,
82        <IOut as IntoIterator>::Item: Send + Sync,
83        FlatMap: Fn(T) -> IOut + Send + Sync + Clone,
84    {
85        match self {
86            GenericIterator::Sequential(x) => GenericIterator::Sequential(x.flat_map(flat_map)),
87            GenericIterator::Rayon(x) => GenericIterator::Rayon(x.flat_map(flat_map)),
88            GenericIterator::Orx(x) => GenericIterator::Orx(x.flat_map(flat_map)),
89        }
90    }
91
92    /// Filter-map transformation for the generic iterator.
93    ///
94    /// See [`filter_map`] for details.
95    ///
96    /// [`filter_map`]: crate::ParIter::filter_map
97    pub fn filter_map<Out, FilterMap>(
98        self,
99        filter_map: FilterMap,
100    ) -> GenericIterator<
101        Out,
102        impl Iterator<Item = Out>,
103        impl rayon::iter::ParallelIterator<Item = Out>,
104        impl ParIter<Item = Out>,
105    >
106    where
107        Out: Send + Sync,
108        FilterMap: Fn(T) -> Option<Out> + Send + Sync + Clone,
109    {
110        match self {
111            GenericIterator::Sequential(x) => GenericIterator::Sequential(x.filter_map(filter_map)),
112            GenericIterator::Rayon(x) => GenericIterator::Rayon(x.filter_map(filter_map)),
113            GenericIterator::Orx(x) => GenericIterator::Orx(x.filter_map(filter_map)),
114        }
115    }
116
117    /// Inspect transformation for the generic iterator.
118    ///
119    /// See [`inspect`] for details.
120    ///
121    /// [`inspect`]: crate::ParIter::inspect
122    pub fn inspect<Operation>(
123        self,
124        operation: Operation,
125    ) -> GenericIterator<
126        T,
127        impl Iterator<Item = T>,
128        impl rayon::iter::ParallelIterator<Item = T>,
129        impl ParIter<Item = T>,
130    >
131    where
132        Operation: Fn(&T) + Sync + Send + Clone,
133    {
134        match self {
135            GenericIterator::Sequential(x) => GenericIterator::Sequential(x.inspect(operation)),
136            GenericIterator::Rayon(x) => GenericIterator::Rayon(x.inspect(operation)),
137            GenericIterator::Orx(x) => GenericIterator::Orx(x.inspect(operation)),
138        }
139    }
140
141    // special item transformations
142
143    /// Flatten transformation for the generic iterator.
144    ///
145    /// See [`flatten`] for details.
146    ///
147    /// [`flatten`]: crate::ParIter::flatten
148    pub fn flatten(
149        self,
150    ) -> GenericIterator<
151        <T as IntoIterator>::Item,
152        impl Iterator<Item = <T as IntoIterator>::Item>,
153        impl rayon::iter::ParallelIterator<Item = <T as IntoIterator>::Item>,
154        impl ParIter<Item = <T as IntoIterator>::Item>,
155    >
156    where
157        T: IntoIterator + rayon::iter::IntoParallelIterator<Item = <T as IntoIterator>::Item>,
158        <T as IntoIterator>::IntoIter: Send + Sync,
159        <T as IntoIterator>::Item: Send + Sync,
160        R: Send + Sync,
161        Self: Send + Sync,
162    {
163        match self {
164            GenericIterator::Sequential(x) => GenericIterator::Sequential(x.flatten()),
165            GenericIterator::Rayon(x) => GenericIterator::Rayon(x.flatten()),
166            GenericIterator::Orx(x) => GenericIterator::Orx(x.flatten()),
167        }
168    }
169}
170
171// special item transformations
172
173impl<'a, T, S, R, O> GenericIterator<&'a T, S, R, O>
174where
175    &'a T: Send + Sync,
176    S: Iterator<Item = &'a T>,
177    R: rayon::iter::ParallelIterator<Item = &'a T>,
178    O: ParIter<Item = &'a T>,
179{
180    /// Copied transformation for the generic iterator.
181    ///
182    /// See [`copied`] for details.
183    ///
184    /// [`copied`]: crate::ParIter::copied
185    pub fn copied(
186        self,
187    ) -> GenericIterator<
188        T,
189        impl Iterator<Item = T> + use<'a, T, S, R, O>,
190        impl rayon::iter::ParallelIterator<Item = T> + use<'a, T, S, R, O>,
191        impl ParIter<Item = T> + use<'a, T, S, R, O>,
192    >
193    where
194        T: Copy + Send + Sync + 'a,
195    {
196        match self {
197            GenericIterator::Sequential(x) => GenericIterator::Sequential(x.copied()),
198            GenericIterator::Rayon(x) => GenericIterator::Rayon(x.copied()),
199            GenericIterator::Orx(x) => GenericIterator::Orx(x.copied()),
200        }
201    }
202
203    /// Cloned transformation for the generic iterator.
204    ///
205    /// See [`cloned`] for details.
206    ///
207    /// [`cloned`]: crate::ParIter::cloned
208    pub fn cloned(
209        self,
210    ) -> GenericIterator<
211        T,
212        impl Iterator<Item = T> + use<'a, T, S, R, O>,
213        impl rayon::iter::ParallelIterator<Item = T> + use<'a, T, S, R, O>,
214        impl ParIter<Item = T> + use<'a, T, S, R, O>,
215    >
216    where
217        T: Clone + Send + Sync + 'a,
218    {
219        match self {
220            GenericIterator::Sequential(x) => GenericIterator::Sequential(x.cloned()),
221            GenericIterator::Rayon(x) => GenericIterator::Rayon(x.cloned()),
222            GenericIterator::Orx(x) => GenericIterator::Orx(x.cloned()),
223        }
224    }
225}
orx_parallel/generic_iterator/transformations.rs

orx_parallel/generic_iterator/
transformations.rs
