rayon/iter/
once.rs

1use crate::iter::plumbing::*;
2use crate::iter::*;
3
4/// Creates a parallel iterator that produces an element exactly once.
5///
6/// This admits no parallelism on its own, but it could be chained to existing
7/// parallel iterators to extend their contents, or otherwise used for any code
8/// that deals with generic parallel iterators.
9///
10/// # Examples
11///
12/// ```
13/// use rayon::prelude::*;
14/// use rayon::iter::once;
15///
16/// let pi = (0..1234).into_par_iter()
17///     .chain(once(-1))
18///     .chain(1234..10_000);
19///
20/// assert_eq!(pi.clone().count(), 10_001);
21/// assert_eq!(pi.clone().filter(|&x| x < 0).count(), 1);
22/// assert_eq!(pi.position_any(|x| x < 0), Some(1234));
23/// ```
24pub fn once<T: Send>(item: T) -> Once<T> {
25    Once { item }
26}
27
28/// Iterator adaptor for [the `once()` function](fn.once.html).
29#[derive(Clone, Debug)]
30pub struct Once<T: Send> {
31    item: T,
32}
33
34impl<T: Send> ParallelIterator for Once<T> {
35    type Item = T;
36
37    fn drive_unindexed<C>(self, consumer: C) -> C::Result
38    where
39        C: UnindexedConsumer<Self::Item>,
40    {
41        self.drive(consumer)
42    }
43
44    fn opt_len(&self) -> Option<usize> {
45        Some(1)
46    }
47}
48
49impl<T: Send> IndexedParallelIterator for Once<T> {
50    fn drive<C>(self, consumer: C) -> C::Result
51    where
52        C: Consumer<Self::Item>,
53    {
54        consumer.into_folder().consume(self.item).complete()
55    }
56
57    fn len(&self) -> usize {
58        1
59    }
60
61    fn with_producer<CB>(self, callback: CB) -> CB::Output
62    where
63        CB: ProducerCallback<Self::Item>,
64    {
65        // Let `OptionProducer` handle it.
66        Some(self.item).into_par_iter().with_producer(callback)
67    }
68}