orx_concurrent_iter/implementations/vec_deque/
con_iter_ref.rs1use 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
11pub 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}