orx_concurrent_iter/implementations/vec_deque/
con_iter_ref.rs

1use super::vec_deque_ref::VecDequeRef;
2use crate::{
3    ConcurrentIter, ExactSizeConcurrentIter,
4    implementations::jagged_arrays::{
5        AsRawSlice, ConIterJaggedRef, JaggedIndex, JaggedIndexer, RawJaggedRef, Slices,
6    },
7};
8use alloc::collections::VecDeque;
9use orx_pseudo_default::PseudoDefault;
10
11/// Concurrent iterator of a reference to a [`VecDeque`].
12///
13/// It can be created by calling [`into_con_iter`] on a `&VecDeque`.
14///
15/// Alternatively, it can be created calling [`con_iter`] on `VecDeque`.
16///
17/// [`into_con_iter`]: crate::IntoConcurrentIter::into_con_iter
18/// [`con_iter`]: crate::ConcurrentIterable::con_iter
19///
20/// # Examples
21///
22/// ```
23/// use orx_concurrent_iter::*;
24///
25/// // &[T]: IntoConcurrentIter
26/// let vec = vec![0, 1, 2, 3];
27/// let slice = &vec[1..3];
28/// let con_iter = slice.into_con_iter();
29/// assert_eq!(con_iter.next(), Some(&1));
30/// assert_eq!(con_iter.next(), Some(&2));
31/// assert_eq!(con_iter.next(), None);
32///
33/// // Vec<T>: ConcurrentIterable
34/// let vec = vec![1, 2];
35/// let con_iter = vec.con_iter();
36/// assert_eq!(con_iter.next(), Some(&1));
37/// assert_eq!(con_iter.next(), Some(&2));
38/// assert_eq!(con_iter.next(), None);
39/// ```
40pub struct ConIterVecDequeRef<'a, T>
41where
42    T: Send + Sync,
43{
44    con_iter: ConIterCore<'a, T>,
45}
46
47impl<'a, T> ConIterVecDequeRef<'a, T>
48where
49    T: Send + Sync,
50{
51    pub(super) fn new(vec_deque_ref: &'a VecDeque<T>) -> Self {
52        let len = vec_deque_ref.len();
53        let vec_deque_ref = VecDequeRef::new(vec_deque_ref);
54        let jagged = RawJaggedRef::new(vec_deque_ref, VecDequeSlicesIndexer, Some(len));
55        let con_iter = ConIterCore::new(jagged, 0);
56        Self { con_iter }
57    }
58}
59
60type ConIterCore<'a, T> = ConIterJaggedRef<'a, T, VecDequeRef<'a, T>, VecDequeSlicesIndexer>;
61
62#[derive(Clone)]
63pub struct VecDequeSlicesIndexer;
64
65impl PseudoDefault for VecDequeSlicesIndexer {
66    fn pseudo_default() -> Self {
67        Self
68    }
69}
70
71impl JaggedIndexer for VecDequeSlicesIndexer {
72    unsafe fn jagged_index_unchecked<'a, T: 'a>(
73        &self,
74        arrays: &impl Slices<'a, T>,
75        flat_index: usize,
76    ) -> JaggedIndex {
77        let first = unsafe { arrays.slice_at_unchecked(0) };
78        match flat_index < first.len() {
79            true => JaggedIndex::new(0, flat_index),
80            false => JaggedIndex::new(1, flat_index - first.len()),
81        }
82    }
83
84    unsafe fn jagged_index_unchecked_from_slice<'a, T: 'a>(
85        &self,
86        arrays: &[impl AsRawSlice<T>],
87        flat_index: usize,
88    ) -> JaggedIndex {
89        match flat_index < arrays[0].length() {
90            true => JaggedIndex::new(0, flat_index),
91            false => JaggedIndex::new(1, flat_index - arrays[0].length()),
92        }
93    }
94}
95
96impl<'a, T> ConcurrentIter for ConIterVecDequeRef<'a, T>
97where
98    T: Send + Sync,
99{
100    type Item = <ConIterCore<'a, T> as ConcurrentIter>::Item;
101
102    type SequentialIter = <ConIterCore<'a, T> as ConcurrentIter>::SequentialIter;
103
104    type ChunkPuller<'i>
105        = <ConIterCore<'a, T> as ConcurrentIter>::ChunkPuller<'i>
106    where
107        Self: 'i;
108
109    fn into_seq_iter(self) -> Self::SequentialIter {
110        self.con_iter.into_seq_iter()
111    }
112
113    fn skip_to_end(&self) {
114        self.con_iter.skip_to_end();
115    }
116
117    fn next(&self) -> Option<Self::Item> {
118        self.con_iter.next()
119    }
120
121    fn next_with_idx(&self) -> Option<(usize, Self::Item)> {
122        self.con_iter.next_with_idx()
123    }
124
125    fn size_hint(&self) -> (usize, Option<usize>) {
126        self.con_iter.size_hint()
127    }
128
129    fn chunk_puller(&self, chunk_size: usize) -> Self::ChunkPuller<'_> {
130        self.con_iter.chunk_puller(chunk_size)
131    }
132}
133
134impl<T> ExactSizeConcurrentIter for ConIterVecDequeRef<'_, T>
135where
136    T: Send + Sync,
137{
138    fn len(&self) -> usize {
139        self.con_iter.len()
140    }
141}