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
// Copyright Materialize, Inc. and contributors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License in the LICENSE file at the
// root of this repository, or online at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! Iterator utilities.
use std::iter::{self, Chain, Once};
/// Extension methods for iterators.
pub trait IteratorExt
where
Self: Iterator + Sized,
{
/// Chains a single `item` onto the end of this iterator.
///
/// Equivalent to `self.chain(iter::once(item))`.
fn chain_one(self, item: Self::Item) -> Chain<Self, Once<Self::Item>> {
self.chain(iter::once(item))
}
/// Reports whether all the elements of the iterator are the same.
///
/// This condition is trivially true for iterators with zero or one elements.
fn all_equal(mut self) -> bool
where
Self::Item: PartialEq,
{
match self.next() {
None => true,
Some(v1) => self.all(|v2| v1 == v2),
}
}
/// Converts the the iterator into an `ExactSizeIterator` reporting the given size.
///
/// The caller is responsible for providing the correct size of the iterator! Providing an
/// incorrect size value will lead to panics and/or incorrect responses to size queries.
///
/// # Panics
///
/// Panics if the given length is not consistent with this iterator's `size_hint`.
fn exact_size(self, len: usize) -> ExactSize<Self> {
let (lower, upper) = self.size_hint();
assert!(
lower <= len && upper.map_or(true, |upper| upper >= len),
"provided length {len} inconsistent with `size_hint`: {:?}",
(lower, upper)
);
ExactSize { inner: self, len }
}
}
impl<I> IteratorExt for I where I: Iterator {}
/// Iterator type returned by [`IteratorExt::exact_size`].
#[derive(Debug)]
pub struct ExactSize<I> {
inner: I,
len: usize,
}
impl<I: Iterator> Iterator for ExactSize<I> {
type Item = I::Item;
fn next(&mut self) -> Option<Self::Item> {
self.len = self.len.saturating_sub(1);
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
(self.len, Some(self.len))
}
}
impl<I: Iterator> ExactSizeIterator for ExactSize<I> {}
#[cfg(test)]
mod tests {
use crate::iter::IteratorExt;
#[crate::test]
fn test_all_equal() {
let empty: [i64; 0] = [];
assert!(empty.iter().all_equal());
assert!([1].iter().all_equal());
assert!([1, 1].iter().all_equal());
assert!(![1, 2].iter().all_equal());
}
}