code_ownership 2.0.0.pre.1 → 2.0.0.pre.3

data/ext/cargo-vendor/rayon-1.10.0/src/iter/intersperse.rs

@@ -1,410 +0,0 @@
-use super::plumbing::*;
-use super::*;
-use std::cell::Cell;
-use std::iter::{self, Fuse};
-
-/// `Intersperse` is an iterator that inserts a particular item between each
-/// item of the adapted iterator.  This struct is created by the
-/// [`intersperse()`] method on [`ParallelIterator`]
-///
-/// [`intersperse()`]: trait.ParallelIterator.html#method.intersperse
-/// [`ParallelIterator`]: trait.ParallelIterator.html
-#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-#[derive(Clone, Debug)]
-pub struct Intersperse<I>
-where
-    I: ParallelIterator,
-    I::Item: Clone,
-{
-    base: I,
-    item: I::Item,
-}
-
-impl<I> Intersperse<I>
-where
-    I: ParallelIterator,
-    I::Item: Clone,
-{
-    /// Creates a new `Intersperse` iterator
-    pub(super) fn new(base: I, item: I::Item) -> Self {
-        Intersperse { base, item }
-    }
-}
-
-impl<I> ParallelIterator for Intersperse<I>
-where
-    I: ParallelIterator,
-    I::Item: Clone + Send,
-{
-    type Item = I::Item;
-
-    fn drive_unindexed<C>(self, consumer: C) -> C::Result
-    where
-        C: UnindexedConsumer<I::Item>,
-    {
-        let consumer1 = IntersperseConsumer::new(consumer, self.item);
-        self.base.drive_unindexed(consumer1)
-    }
-
-    fn opt_len(&self) -> Option<usize> {
-        match self.base.opt_len()? {
-            0 => Some(0),
-            len => len.checked_add(len - 1),
-        }
-    }
-}
-
-impl<I> IndexedParallelIterator for Intersperse<I>
-where
-    I: IndexedParallelIterator,
-    I::Item: Clone + Send,
-{
-    fn drive<C>(self, consumer: C) -> C::Result
-    where
-        C: Consumer<Self::Item>,
-    {
-        let consumer1 = IntersperseConsumer::new(consumer, self.item);
-        self.base.drive(consumer1)
-    }
-
-    fn len(&self) -> usize {
-        let len = self.base.len();
-        if len > 0 {
-            len.checked_add(len - 1).expect("overflow")
-        } else {
-            0
-        }
-    }
-
-    fn with_producer<CB>(self, callback: CB) -> CB::Output
-    where
-        CB: ProducerCallback<Self::Item>,
-    {
-        let len = self.len();
-        return self.base.with_producer(Callback {
-            callback,
-            item: self.item,
-            len,
-        });
-
-        struct Callback<CB, T> {
-            callback: CB,
-            item: T,
-            len: usize,
-        }
-
-        impl<T, CB> ProducerCallback<T> for Callback<CB, T>
-        where
-            CB: ProducerCallback<T>,
-            T: Clone + Send,
-        {
-            type Output = CB::Output;
-
-            fn callback<P>(self, base: P) -> CB::Output
-            where
-                P: Producer<Item = T>,
-            {
-                let producer = IntersperseProducer::new(base, self.item, self.len);
-                self.callback.callback(producer)
-            }
-        }
-    }
-}
-
-struct IntersperseProducer<P>
-where
-    P: Producer,
-{
-    base: P,
-    item: P::Item,
-    len: usize,
-    clone_first: bool,
-}
-
-impl<P> IntersperseProducer<P>
-where
-    P: Producer,
-{
-    fn new(base: P, item: P::Item, len: usize) -> Self {
-        IntersperseProducer {
-            base,
-            item,
-            len,
-            clone_first: false,
-        }
-    }
-}
-
-impl<P> Producer for IntersperseProducer<P>
-where
-    P: Producer,
-    P::Item: Clone + Send,
-{
-    type Item = P::Item;
-    type IntoIter = IntersperseIter<P::IntoIter>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        IntersperseIter {
-            base: self.base.into_iter().fuse(),
-            item: self.item,
-            clone_first: self.len > 0 && self.clone_first,
-
-            // If there's more than one item, then even lengths end the opposite
-            // of how they started with respect to interspersed clones.
-            clone_last: self.len > 1 && ((self.len & 1 == 0) ^ self.clone_first),
-        }
-    }
-
-    fn min_len(&self) -> usize {
-        self.base.min_len()
-    }
-    fn max_len(&self) -> usize {
-        self.base.max_len()
-    }
-
-    fn split_at(self, index: usize) -> (Self, Self) {
-        debug_assert!(index <= self.len);
-
-        // The left needs half of the items from the base producer, and the
-        // other half will be our interspersed item.  If we're not leading with
-        // a cloned item, then we need to round up the base number of items,
-        // otherwise round down.
-        let base_index = (index + !self.clone_first as usize) / 2;
-        let (left_base, right_base) = self.base.split_at(base_index);
-
-        let left = IntersperseProducer {
-            base: left_base,
-            item: self.item.clone(),
-            len: index,
-            clone_first: self.clone_first,
-        };
-
-        let right = IntersperseProducer {
-            base: right_base,
-            item: self.item,
-            len: self.len - index,
-
-            // If the index is odd, the right side toggles `clone_first`.
-            clone_first: (index & 1 == 1) ^ self.clone_first,
-        };
-
-        (left, right)
-    }
-
-    fn fold_with<F>(self, folder: F) -> F
-    where
-        F: Folder<Self::Item>,
-    {
-        let folder1 = IntersperseFolder {
-            base: folder,
-            item: self.item,
-            clone_first: self.clone_first,
-        };
-        self.base.fold_with(folder1).base
-    }
-}
-
-struct IntersperseIter<I>
-where
-    I: Iterator,
-{
-    base: Fuse<I>,
-    item: I::Item,
-    clone_first: bool,
-    clone_last: bool,
-}
-
-impl<I> Iterator for IntersperseIter<I>
-where
-    I: DoubleEndedIterator + ExactSizeIterator,
-    I::Item: Clone,
-{
-    type Item = I::Item;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.clone_first {
-            self.clone_first = false;
-            Some(self.item.clone())
-        } else if let next @ Some(_) = self.base.next() {
-            // If there are any items left, we'll need another clone in front.
-            self.clone_first = self.base.len() != 0;
-            next
-        } else if self.clone_last {
-            self.clone_last = false;
-            Some(self.item.clone())
-        } else {
-            None
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.len();
-        (len, Some(len))
-    }
-}
-
-impl<I> DoubleEndedIterator for IntersperseIter<I>
-where
-    I: DoubleEndedIterator + ExactSizeIterator,
-    I::Item: Clone,
-{
-    fn next_back(&mut self) -> Option<Self::Item> {
-        if self.clone_last {
-            self.clone_last = false;
-            Some(self.item.clone())
-        } else if let next_back @ Some(_) = self.base.next_back() {
-            // If there are any items left, we'll need another clone in back.
-            self.clone_last = self.base.len() != 0;
-            next_back
-        } else if self.clone_first {
-            self.clone_first = false;
-            Some(self.item.clone())
-        } else {
-            None
-        }
-    }
-}
-
-impl<I> ExactSizeIterator for IntersperseIter<I>
-where
-    I: DoubleEndedIterator + ExactSizeIterator,
-    I::Item: Clone,
-{
-    fn len(&self) -> usize {
-        let len = self.base.len();
-        len + len.saturating_sub(1) + self.clone_first as usize + self.clone_last as usize
-    }
-}
-
-struct IntersperseConsumer<C, T> {
-    base: C,
-    item: T,
-    clone_first: Cell<bool>,
-}
-
-impl<C, T> IntersperseConsumer<C, T>
-where
-    C: Consumer<T>,
-{
-    fn new(base: C, item: T) -> Self {
-        IntersperseConsumer {
-            base,
-            item,
-            clone_first: false.into(),
-        }
-    }
-}
-
-impl<C, T> Consumer<T> for IntersperseConsumer<C, T>
-where
-    C: Consumer<T>,
-    T: Clone + Send,
-{
-    type Folder = IntersperseFolder<C::Folder, T>;
-    type Reducer = C::Reducer;
-    type Result = C::Result;
-
-    fn split_at(mut self, index: usize) -> (Self, Self, Self::Reducer) {
-        // We'll feed twice as many items to the base consumer, except if we're
-        // not currently leading with a cloned item, then it's one less.
-        let base_index = index + index.saturating_sub(!self.clone_first.get() as usize);
-        let (left, right, reducer) = self.base.split_at(base_index);
-
-        let right = IntersperseConsumer {
-            base: right,
-            item: self.item.clone(),
-            clone_first: true.into(),
-        };
-        self.base = left;
-        (self, right, reducer)
-    }
-
-    fn into_folder(self) -> Self::Folder {
-        IntersperseFolder {
-            base: self.base.into_folder(),
-            item: self.item,
-            clone_first: self.clone_first.get(),
-        }
-    }
-
-    fn full(&self) -> bool {
-        self.base.full()
-    }
-}
-
-impl<C, T> UnindexedConsumer<T> for IntersperseConsumer<C, T>
-where
-    C: UnindexedConsumer<T>,
-    T: Clone + Send,
-{
-    fn split_off_left(&self) -> Self {
-        let left = IntersperseConsumer {
-            base: self.base.split_off_left(),
-            item: self.item.clone(),
-            clone_first: self.clone_first.clone(),
-        };
-        self.clone_first.set(true);
-        left
-    }
-
-    fn to_reducer(&self) -> Self::Reducer {
-        self.base.to_reducer()
-    }
-}
-
-struct IntersperseFolder<C, T> {
-    base: C,
-    item: T,
-    clone_first: bool,
-}
-
-impl<C, T> Folder<T> for IntersperseFolder<C, T>
-where
-    C: Folder<T>,
-    T: Clone,
-{
-    type Result = C::Result;
-
-    fn consume(mut self, item: T) -> Self {
-        if self.clone_first {
-            self.base = self.base.consume(self.item.clone());
-            if self.base.full() {
-                return self;
-            }
-        } else {
-            self.clone_first = true;
-        }
-        self.base = self.base.consume(item);
-        self
-    }
-
-    fn consume_iter<I>(self, iter: I) -> Self
-    where
-        I: IntoIterator<Item = T>,
-    {
-        let mut clone_first = self.clone_first;
-        let between_item = self.item;
-        let base = self.base.consume_iter(iter.into_iter().flat_map(|item| {
-            let first = if clone_first {
-                Some(between_item.clone())
-            } else {
-                clone_first = true;
-                None
-            };
-            first.into_iter().chain(iter::once(item))
-        }));
-        IntersperseFolder {
-            base,
-            item: between_item,
-            clone_first,
-        }
-    }
-
-    fn complete(self) -> C::Result {
-        self.base.complete()
-    }
-
-    fn full(&self) -> bool {
-        self.base.full()
-    }
-}

data/ext/cargo-vendor/rayon-1.10.0/src/iter/len.rs

@@ -1,270 +0,0 @@
-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)
-    }
-}