/rust/registry/src/index.crates.io-6f17d22bba15001f/rayon-1.10.0/src/iter/len.rs

Source (jump to first uncovered line)
use super::plumbing::*;
use super::*;

/// `MinLen` is an iterator that imposes a minimum length on iterator splits.
/// This struct is created by the [`with_min_len()`] method on [`IndexedParallelIterator`]
///
/// [`with_min_len()`]: trait.IndexedParallelIterator.html#method.with_min_len
/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[derive(Debug, Clone)]
pub struct MinLen<I: IndexedParallelIterator> {
    base: I,
    min: usize,
}

impl<I> MinLen<I>
where
    I: IndexedParallelIterator,
{
    /// Creates a new `MinLen` iterator.
    pub(super) fn new(base: I, min: usize) -> Self {
        MinLen { base, min }
    }
}

impl<I> ParallelIterator for MinLen<I>
where
    I: IndexedParallelIterator,
{
    type Item = I::Item;

    fn drive_unindexed<C>(self, consumer: C) -> C::Result
    where
        C: UnindexedConsumer<Self::Item>,
    {
        bridge(self, consumer)
    }

    fn opt_len(&self) -> Option<usize> {
        Some(self.len())
    }
}

impl<I> IndexedParallelIterator for MinLen<I>
where
    I: IndexedParallelIterator,
{
    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
        bridge(self, consumer)
    }

    fn len(&self) -> usize {
        self.base.len()
    }

    fn with_producer<CB>(self, callback: CB) -> CB::Output
    where
        CB: ProducerCallback<Self::Item>,
    {
        return self.base.with_producer(Callback {
            callback,
            min: self.min,
        });

        struct Callback<CB> {
            callback: CB,
            min: usize,
        }

        impl<T, CB> ProducerCallback<T> for Callback<CB>
        where
            CB: ProducerCallback<T>,
        {
            type Output = CB::Output;
            fn callback<P>(self, base: P) -> CB::Output
            where
                P: Producer<Item = T>,
            {
                let producer = MinLenProducer {
                    base,
                    min: self.min,
                };
                self.callback.callback(producer)
            }
        }
    }
}

/// ////////////////////////////////////////////////////////////////////////
/// `MinLenProducer` implementation

struct MinLenProducer<P> {
    base: P,
    min: usize,
}

impl<P> Producer for MinLenProducer<P>
where
    P: Producer,
{
    type Item = P::Item;
    type IntoIter = P::IntoIter;

    fn into_iter(self) -> Self::IntoIter {
        self.base.into_iter()
    }

    fn min_len(&self) -> usize {
        Ord::max(self.min, self.base.min_len())
    }

    fn max_len(&self) -> usize {
        self.base.max_len()
    }

    fn split_at(self, index: usize) -> (Self, Self) {
        let (left, right) = self.base.split_at(index);
        (
            MinLenProducer {
                base: left,
                min: self.min,
            },
            MinLenProducer {
                base: right,
                min: self.min,
            },
        )
    }

    fn fold_with<F>(self, folder: F) -> F
    where
        F: Folder<Self::Item>,
    {
        self.base.fold_with(folder)
    }
}

/// `MaxLen` is an iterator that imposes a maximum length on iterator splits.
/// This struct is created by the [`with_max_len()`] method on [`IndexedParallelIterator`]
///
/// [`with_max_len()`]: trait.IndexedParallelIterator.html#method.with_max_len
/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[derive(Debug, Clone)]
pub struct MaxLen<I: IndexedParallelIterator> {
    base: I,
    max: usize,
}

impl<I> MaxLen<I>
where
    I: IndexedParallelIterator,
{
    /// Creates a new `MaxLen` iterator.
    pub(super) fn new(base: I, max: usize) -> Self {
        MaxLen { base, max }
    }
}

impl<I> ParallelIterator for MaxLen<I>
where
    I: IndexedParallelIterator,
{
    type Item = I::Item;

    fn drive_unindexed<C>(self, consumer: C) -> C::Result
    where
        C: UnindexedConsumer<Self::Item>,
    {
        bridge(self, consumer)
    }

    fn opt_len(&self) -> Option<usize> {
        Some(self.len())
    }
}

impl<I> IndexedParallelIterator for MaxLen<I>
where
    I: IndexedParallelIterator,
{
    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
        bridge(self, consumer)
    }

    fn len(&self) -> usize {
        self.base.len()
    }

    fn with_producer<CB>(self, callback: CB) -> CB::Output
    where
        CB: ProducerCallback<Self::Item>,
    {
        return self.base.with_producer(Callback {
            callback,
            max: self.max,
        });

        struct Callback<CB> {
            callback: CB,
            max: usize,
        }

        impl<T, CB> ProducerCallback<T> for Callback<CB>
        where
            CB: ProducerCallback<T>,
        {
            type Output = CB::Output;
            fn callback<P>(self, base: P) -> CB::Output
            where
                P: Producer<Item = T>,
            {
                let producer = MaxLenProducer {
                    base,
                    max: self.max,
                };
                self.callback.callback(producer)
            }
        }
    }
}

/// ////////////////////////////////////////////////////////////////////////
/// `MaxLenProducer` implementation

struct MaxLenProducer<P> {
    base: P,
    max: usize,
}

impl<P> Producer for MaxLenProducer<P>
where
    P: Producer,
{
    type Item = P::Item;
    type IntoIter = P::IntoIter;

    fn into_iter(self) -> Self::IntoIter {
        self.base.into_iter()
    }

    fn min_len(&self) -> usize {
        self.base.min_len()
    }

    fn max_len(&self) -> usize {
        Ord::min(self.max, self.base.max_len())
    }

    fn split_at(self, index: usize) -> (Self, Self) {
        let (left, right) = self.base.split_at(index);
        (
            MaxLenProducer {
                base: left,
                max: self.max,
            },
            MaxLenProducer {
                base: right,
                max: self.max,
            },
        )
    }

    fn fold_with<F>(self, folder: F) -> F
    where
        F: Folder<Self::Item>,
    {
        self.base.fold_with(folder)
    }
}

Coverage Report

Created: 2025-02-21 07:11

Line	Count	Source (jump to first uncovered line)
1		use super::plumbing::*;
2		use super::*;
3
4		/// `MinLen` is an iterator that imposes a minimum length on iterator splits.
5		/// This struct is created by the [`with_min_len()`] method on [`IndexedParallelIterator`]
6		///
7		/// [`with_min_len()`]: trait.IndexedParallelIterator.html#method.with_min_len
8		/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
9		#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
10		#[derive(Debug, Clone)]
11		pub struct MinLen<I: IndexedParallelIterator> {
12		base: I,
13		min: usize,
14		}
15
16		impl<I> MinLen<I>
17		where
18		I: IndexedParallelIterator,
19		{
20		/// Creates a new `MinLen` iterator.
21	0	pub(super) fn new(base: I, min: usize) -> Self {
22	0	MinLen { base, min }
23	0	}
24		}
25
26		impl<I> ParallelIterator for MinLen<I>
27		where
28		I: IndexedParallelIterator,
29		{
30		type Item = I::Item;
31
32	0	fn drive_unindexed<C>(self, consumer: C) -> C::Result
33	0	where
34	0	C: UnindexedConsumer<Self::Item>,
35	0	{
36	0	bridge(self, consumer)
37	0	}
38
39	0	fn opt_len(&self) -> Option<usize> {
40	0	Some(self.len())
41	0	}
42		}
43
44		impl<I> IndexedParallelIterator for MinLen<I>
45		where
46		I: IndexedParallelIterator,
47		{
48	0	fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
49	0	bridge(self, consumer)
50	0	}
51
52	0	fn len(&self) -> usize {
53	0	self.base.len()
54	0	}
55
56	0	fn with_producer<CB>(self, callback: CB) -> CB::Output
57	0	where
58	0	CB: ProducerCallback<Self::Item>,
59	0	{
60	0	return self.base.with_producer(Callback {
61	0	callback,
62	0	min: self.min,
63	0	});
64
65		struct Callback<CB> {
66		callback: CB,
67		min: usize,
68		}
69
70		impl<T, CB> ProducerCallback<T> for Callback<CB>
71		where
72		CB: ProducerCallback<T>,
73		{
74		type Output = CB::Output;
75	0	fn callback<P>(self, base: P) -> CB::Output
76	0	where
77	0	P: Producer<Item = T>,
78	0	{
79	0	let producer = MinLenProducer {
80	0	base,
81	0	min: self.min,
82	0	};
83	0	self.callback.callback(producer)
84	0	}
85		}
86	0	}
87		}
88
89		/// ////////////////////////////////////////////////////////////////////////
90		/// `MinLenProducer` implementation
91
92		struct MinLenProducer<P> {
93		base: P,
94		min: usize,
95		}
96
97		impl<P> Producer for MinLenProducer<P>
98		where
99		P: Producer,
100		{
101		type Item = P::Item;
102		type IntoIter = P::IntoIter;
103
104	0	fn into_iter(self) -> Self::IntoIter {
105	0	self.base.into_iter()
106	0	}
107
108	0	fn min_len(&self) -> usize {
109	0	Ord::max(self.min, self.base.min_len())
110	0	}
111
112	0	fn max_len(&self) -> usize {
113	0	self.base.max_len()
114	0	}
115
116	0	fn split_at(self, index: usize) -> (Self, Self) {
117	0	let (left, right) = self.base.split_at(index);
118	0	(
119	0	MinLenProducer {
120	0	base: left,
121	0	min: self.min,
122	0	},
123	0	MinLenProducer {
124	0	base: right,
125	0	min: self.min,
126	0	},
127	0	)
128	0	}
129
130	0	fn fold_with<F>(self, folder: F) -> F
131	0	where
132	0	F: Folder<Self::Item>,
133	0	{
134	0	self.base.fold_with(folder)
135	0	}
136		}
137
138		/// `MaxLen` is an iterator that imposes a maximum length on iterator splits.
139		/// This struct is created by the [`with_max_len()`] method on [`IndexedParallelIterator`]
140		///
141		/// [`with_max_len()`]: trait.IndexedParallelIterator.html#method.with_max_len
142		/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html
143		#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
144		#[derive(Debug, Clone)]
145		pub struct MaxLen<I: IndexedParallelIterator> {
146		base: I,
147		max: usize,
148		}
149
150		impl<I> MaxLen<I>
151		where
152		I: IndexedParallelIterator,
153		{
154		/// Creates a new `MaxLen` iterator.
155	0	pub(super) fn new(base: I, max: usize) -> Self {
156	0	MaxLen { base, max }
157	0	} Unexecuted instantiation: <rayon::iter::len::MaxLen<rayon::slice::chunks::ChunksMut<surrealdb_core::sql::value::value::Value>>>::new Unexecuted instantiation: <rayon::iter::len::MaxLen<_>>::new
158		}
159
160		impl<I> ParallelIterator for MaxLen<I>
161		where
162		I: IndexedParallelIterator,
163		{
164		type Item = I::Item;
165
166	0	fn drive_unindexed<C>(self, consumer: C) -> C::Result
167	0	where
168	0	C: UnindexedConsumer<Self::Item>,
169	0	{
170	0	bridge(self, consumer)
171	0	}
172
173	0	fn opt_len(&self) -> Option<usize> {
174	0	Some(self.len())
175	0	}
176		}
177
178		impl<I> IndexedParallelIterator for MaxLen<I>
179		where
180		I: IndexedParallelIterator,
181		{
182	0	fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
183	0	bridge(self, consumer)
184	0	}
185
186	0	fn len(&self) -> usize {
187	0	self.base.len()
188	0	} Unexecuted instantiation: <rayon::iter::len::MaxLen<rayon::slice::chunks::ChunksMut<surrealdb_core::sql::value::value::Value>> as rayon::iter::IndexedParallelIterator>::len Unexecuted instantiation: <rayon::iter::len::MaxLen<_> as rayon::iter::IndexedParallelIterator>::len
189
190	0	fn with_producer<CB>(self, callback: CB) -> CB::Output
191	0	where
192	0	CB: ProducerCallback<Self::Item>,
193	0	{
194	0	return self.base.with_producer(Callback {
195	0	callback,
196	0	max: self.max,
197	0	});
198
199		struct Callback<CB> {
200		callback: CB,
201		max: usize,
202		}
203
204		impl<T, CB> ProducerCallback<T> for Callback<CB>
205		where
206		CB: ProducerCallback<T>,
207		{
208		type Output = CB::Output;
209	0	fn callback<P>(self, base: P) -> CB::Output
210	0	where
211	0	P: Producer<Item = T>,
212	0	{
213	0	let producer = MaxLenProducer {
214	0	base,
215	0	max: self.max,
216	0	};
217	0	self.callback.callback(producer)
218	0	} Unexecuted instantiation: <<rayon::iter::len::MaxLen<_> as rayon::iter::IndexedParallelIterator>::with_producer::Callback<<rayon::iter::enumerate::Enumerate<_> as rayon::iter::IndexedParallelIterator>::with_producer::Callback<rayon::iter::plumbing::bridge::Callback<rayon::iter::map::MapConsumer<rayon::iter::collect::consumer::CollectConsumer<(usize, usize, rayon::slice::mergesort::MergesortResult)>, rayon::slice::mergesort::par_mergesort<surrealdb_core::sql::value::value::Value, <ext_sort::buffer::LimitedBuffer<surrealdb_core::sql::value::value::Value> as rayon::slice::ParallelSliceMut<surrealdb_core::sql::value::value::Value>>::par_sort_by<<surrealdb_core::dbs::file::FileCollector>::sort_and_take_vec::{closure#0}::{closure#2}::{closure#0}>::{closure#0}>::{closure#0}>>>> as rayon::iter::plumbing::ProducerCallback<&mut [surrealdb_core::sql::value::value::Value]>>::callback::<rayon::slice::chunks::ChunksMutProducer<surrealdb_core::sql::value::value::Value>> Unexecuted instantiation: <<rayon::iter::len::MaxLen<_> as rayon::iter::IndexedParallelIterator>::with_producer::Callback<<rayon::iter::enumerate::Enumerate<_> as rayon::iter::IndexedParallelIterator>::with_producer::Callback<rayon::iter::plumbing::bridge::Callback<rayon::iter::map::MapConsumer<rayon::iter::extend::ListVecConsumer, rayon::slice::mergesort::par_mergesort<surrealdb_core::sql::value::value::Value, <ext_sort::buffer::LimitedBuffer<surrealdb_core::sql::value::value::Value> as rayon::slice::ParallelSliceMut<surrealdb_core::sql::value::value::Value>>::par_sort_by<<surrealdb_core::dbs::file::FileCollector>::sort_and_take_vec::{closure#0}::{closure#2}::{closure#0}>::{closure#0}>::{closure#0}>>>> as rayon::iter::plumbing::ProducerCallback<&mut [surrealdb_core::sql::value::value::Value]>>::callback::<rayon::slice::chunks::ChunksMutProducer<surrealdb_core::sql::value::value::Value>> Unexecuted instantiation: <<rayon::iter::len::MaxLen<_> as rayon::iter::IndexedParallelIterator>::with_producer::Callback<_> as rayon::iter::plumbing::ProducerCallback<_>>::callback::<_>
219		}
220	0	} Unexecuted instantiation: <rayon::iter::len::MaxLen<rayon::slice::chunks::ChunksMut<surrealdb_core::sql::value::value::Value>> as rayon::iter::IndexedParallelIterator>::with_producer::<<rayon::iter::enumerate::Enumerate<_> as rayon::iter::IndexedParallelIterator>::with_producer::Callback<rayon::iter::plumbing::bridge::Callback<rayon::iter::map::MapConsumer<rayon::iter::collect::consumer::CollectConsumer<(usize, usize, rayon::slice::mergesort::MergesortResult)>, rayon::slice::mergesort::par_mergesort<surrealdb_core::sql::value::value::Value, <ext_sort::buffer::LimitedBuffer<surrealdb_core::sql::value::value::Value> as rayon::slice::ParallelSliceMut<surrealdb_core::sql::value::value::Value>>::par_sort_by<<surrealdb_core::dbs::file::FileCollector>::sort_and_take_vec::{closure#0}::{closure#2}::{closure#0}>::{closure#0}>::{closure#0}>>>> Unexecuted instantiation: <rayon::iter::len::MaxLen<rayon::slice::chunks::ChunksMut<surrealdb_core::sql::value::value::Value>> as rayon::iter::IndexedParallelIterator>::with_producer::<<rayon::iter::enumerate::Enumerate<_> as rayon::iter::IndexedParallelIterator>::with_producer::Callback<rayon::iter::plumbing::bridge::Callback<rayon::iter::map::MapConsumer<rayon::iter::extend::ListVecConsumer, rayon::slice::mergesort::par_mergesort<surrealdb_core::sql::value::value::Value, <ext_sort::buffer::LimitedBuffer<surrealdb_core::sql::value::value::Value> as rayon::slice::ParallelSliceMut<surrealdb_core::sql::value::value::Value>>::par_sort_by<<surrealdb_core::dbs::file::FileCollector>::sort_and_take_vec::{closure#0}::{closure#2}::{closure#0}>::{closure#0}>::{closure#0}>>>> Unexecuted instantiation: <rayon::iter::len::MaxLen<_> as rayon::iter::IndexedParallelIterator>::with_producer::<_>
221		}
222
223		/// ////////////////////////////////////////////////////////////////////////
224		/// `MaxLenProducer` implementation
225
226		struct MaxLenProducer<P> {
227		base: P,
228		max: usize,
229		}
230
231		impl<P> Producer for MaxLenProducer<P>
232		where
233		P: Producer,
234		{
235		type Item = P::Item;
236		type IntoIter = P::IntoIter;
237
238	0	fn into_iter(self) -> Self::IntoIter {
239	0	self.base.into_iter()
240	0	} Unexecuted instantiation: <rayon::iter::len::MaxLenProducer<rayon::slice::chunks::ChunksMutProducer<surrealdb_core::sql::value::value::Value>> as rayon::iter::plumbing::Producer>::into_iter Unexecuted instantiation: <rayon::iter::len::MaxLenProducer<_> as rayon::iter::plumbing::Producer>::into_iter
241
242	0	fn min_len(&self) -> usize {
243	0	self.base.min_len()
244	0	} Unexecuted instantiation: <rayon::iter::len::MaxLenProducer<rayon::slice::chunks::ChunksMutProducer<surrealdb_core::sql::value::value::Value>> as rayon::iter::plumbing::Producer>::min_len Unexecuted instantiation: <rayon::iter::len::MaxLenProducer<_> as rayon::iter::plumbing::Producer>::min_len
245
246	0	fn max_len(&self) -> usize {
247	0	Ord::min(self.max, self.base.max_len())
248	0	} Unexecuted instantiation: <rayon::iter::len::MaxLenProducer<rayon::slice::chunks::ChunksMutProducer<surrealdb_core::sql::value::value::Value>> as rayon::iter::plumbing::Producer>::max_len Unexecuted instantiation: <rayon::iter::len::MaxLenProducer<_> as rayon::iter::plumbing::Producer>::max_len
249
250	0	fn split_at(self, index: usize) -> (Self, Self) {
251	0	let (left, right) = self.base.split_at(index);
252	0	(
253	0	MaxLenProducer {
254	0	base: left,
255	0	max: self.max,
256	0	},
257	0	MaxLenProducer {
258	0	base: right,
259	0	max: self.max,
260	0	},
261	0	)
262	0	} Unexecuted instantiation: <rayon::iter::len::MaxLenProducer<rayon::slice::chunks::ChunksMutProducer<surrealdb_core::sql::value::value::Value>> as rayon::iter::plumbing::Producer>::split_at Unexecuted instantiation: <rayon::iter::len::MaxLenProducer<_> as rayon::iter::plumbing::Producer>::split_at
263
264	0	fn fold_with<F>(self, folder: F) -> F
265	0	where
266	0	F: Folder<Self::Item>,
267	0	{
268	0	self.base.fold_with(folder)
269	0	}
270		}