orx-concurrent-iter 3.3.0

A thread-safe and ergonomic concurrent iterator trait and efficient lock-free implementations.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use super::vec_deque_ref::VecDequeRef;
use crate::{
    ConcurrentIter, ExactSizeConcurrentIter,
    implementations::jagged_arrays::{
        AsRawSlice, ConIterJaggedRef, JaggedIndex, JaggedIndexer, RawJaggedRef, Slices,
    },
};
use alloc::collections::VecDeque;
use orx_pseudo_default::PseudoDefault;

/// Concurrent iterator of a reference to a [`VecDeque`].
///
/// It can be created by calling [`into_con_iter`] on a `&VecDeque`.
///
/// Alternatively, it can be created calling [`con_iter`] on `VecDeque`.
///
/// [`into_con_iter`]: crate::IntoConcurrentIter::into_con_iter
/// [`con_iter`]: crate::ConcurrentIterable::con_iter
///
/// # Examples
///
/// ```
/// use orx_concurrent_iter::*;
///
/// // &[T]: IntoConcurrentIter
/// let vec = vec![0, 1, 2, 3];
/// let slice = &vec[1..3];
/// let con_iter = slice.into_con_iter();
/// assert_eq!(con_iter.next(), Some(&1));
/// assert_eq!(con_iter.next(), Some(&2));
/// assert_eq!(con_iter.next(), None);
///
/// // Vec<T>: ConcurrentIterable
/// let vec = vec![1, 2];
/// let con_iter = vec.con_iter();
/// assert_eq!(con_iter.next(), Some(&1));
/// assert_eq!(con_iter.next(), Some(&2));
/// assert_eq!(con_iter.next(), None);
/// ```
pub struct ConIterVecDequeRef<'a, T>
where
    T: 'a + Sync,
{
    con_iter: ConIterCore<'a, T>,
}

impl<'a, T> ConIterVecDequeRef<'a, T>
where
    T: 'a + Sync,
{
    pub(super) fn new(vec_deque_ref: &'a VecDeque<T>) -> Self {
        let len = vec_deque_ref.len();
        let vec_deque_ref = VecDequeRef::new(vec_deque_ref);
        let jagged = RawJaggedRef::new(vec_deque_ref, VecDequeSlicesIndexer, Some(len));
        let con_iter = ConIterCore::new(jagged, 0);
        Self { con_iter }
    }
}

type ConIterCore<'a, T> = ConIterJaggedRef<'a, T, VecDequeRef<'a, T>, VecDequeSlicesIndexer>;

#[derive(Clone)]
pub struct VecDequeSlicesIndexer;

impl PseudoDefault for VecDequeSlicesIndexer {
    fn pseudo_default() -> Self {
        Self
    }
}

impl JaggedIndexer for VecDequeSlicesIndexer {
    unsafe fn jagged_index_unchecked<'a, T: 'a>(
        &self,
        arrays: &impl Slices<'a, T>,
        flat_index: usize,
    ) -> JaggedIndex {
        let first = unsafe { arrays.slice_at_unchecked(0) };
        match flat_index < first.len() {
            true => JaggedIndex::new(0, flat_index),
            false => JaggedIndex::new(1, flat_index - first.len()),
        }
    }

    unsafe fn jagged_index_unchecked_from_slice<'a, T: 'a>(
        &self,
        arrays: &[impl AsRawSlice<T>],
        flat_index: usize,
    ) -> JaggedIndex {
        match flat_index < arrays[0].length() {
            true => JaggedIndex::new(0, flat_index),
            false => JaggedIndex::new(1, flat_index - arrays[0].length()),
        }
    }
}

impl<'a, T> ConcurrentIter for ConIterVecDequeRef<'a, T>
where
    T: 'a + Sync,
{
    type Item = <ConIterCore<'a, T> as ConcurrentIter>::Item;

    type SequentialIter = <ConIterCore<'a, T> as ConcurrentIter>::SequentialIter;

    type ChunkPuller<'i>
        = <ConIterCore<'a, T> as ConcurrentIter>::ChunkPuller<'i>
    where
        Self: 'i;

    fn into_seq_iter(self) -> Self::SequentialIter {
        self.con_iter.into_seq_iter()
    }

    fn skip_to_end(&self) {
        self.con_iter.skip_to_end();
    }

    fn next(&self) -> Option<Self::Item> {
        self.con_iter.next()
    }

    fn next_with_idx(&self) -> Option<(usize, Self::Item)> {
        self.con_iter.next_with_idx()
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.con_iter.size_hint()
    }

    fn is_completed_when_none_returned(&self) -> bool {
        true
    }

    fn chunk_puller(&self, chunk_size: usize) -> Self::ChunkPuller<'_> {
        self.con_iter.chunk_puller(chunk_size)
    }
}

impl<T> ExactSizeConcurrentIter for ConIterVecDequeRef<'_, T>
where
    T: Sync,
{
    fn len(&self) -> usize {
        self.con_iter.len()
    }
}